TP2_G1
Data Structures | Macros | Typedefs | Enumerations
MK64F12.h File Reference

CMSIS Peripheral Access Layer for MK64F12. More...

#include "core_cm4.h"
#include "system_MK64F12.h"

Go to the source code of this file.

Data Structures

struct  ADC_Type
 
struct  AIPS_Type
 
struct  AXBS_Type
 
struct  CAN_Type
 
struct  CAU_Type
 
struct  CMP_Type
 
struct  CMT_Type
 
struct  CRC_Type
 
struct  DAC_Type
 
struct  DMA_Type
 
struct  DMAMUX_Type
 
struct  ENET_Type
 
struct  EWM_Type
 
struct  FB_Type
 
struct  FMC_Type
 
struct  FTFE_Type
 
struct  FTM_Type
 
struct  GPIO_Type
 
struct  I2C_Type
 
struct  I2S_Type
 
struct  LLWU_Type
 
struct  LPTMR_Type
 
struct  MCG_Type
 
struct  MCM_Type
 
struct  NV_Type
 
struct  OSC_Type
 
struct  PDB_Type
 
struct  PIT_Type
 
struct  PMC_Type
 
struct  PORT_Type
 
struct  RCM_Type
 
struct  RFSYS_Type
 
struct  RFVBAT_Type
 
struct  RNG_Type
 
struct  RTC_Type
 
struct  SDHC_Type
 
struct  SIM_Type
 
struct  SMC_Type
 
struct  SPI_Type
 
struct  SYSMPU_Type
 
struct  UART_Type
 
struct  USB_Type
 
struct  USBDCD_Type
 
struct  VREF_Type
 
struct  WDOG_Type
 

Macros

#define _MK64F12_H_
 
#define MCU_MEM_MAP_VERSION   0x0200U
 
#define MCU_MEM_MAP_VERSION_MINOR   0x0009U
 
#define BITBAND_REGADDR(Reg, Bit)   (0x42000000u + (32u*((uint32_t)&(Reg) - (uint32_t)0x40000000u)) + (4u*((uint32_t)(Bit))))
 Macro to calculate address of an aliased word in the peripheral bitband area for a peripheral register and bit (bit band region 0x40000000 to 0x400FFFFF). More...
 
#define BITBAND_REG32(Reg, Bit)   (*((uint32_t volatile*)(BITBAND_REGADDR((Reg),(Bit)))))
 Macro to access a single bit of a peripheral register (bit band region 0x40000000 to 0x400FFFFF) using the bit-band alias region access. Can be used for peripherals with 32bit access allowed. More...
 
#define BITBAND_REG(Reg, Bit)   (BITBAND_REG32((Reg),(Bit)))
 
#define BITBAND_REG16(Reg, Bit)   (*((uint16_t volatile*)(BITBAND_REGADDR((Reg),(Bit)))))
 Macro to access a single bit of a peripheral register (bit band region 0x40000000 to 0x400FFFFF) using the bit-band alias region access. Can be used for peripherals with 16bit access allowed. More...
 
#define BITBAND_REG8(Reg, Bit)   (*((uint8_t volatile*)(BITBAND_REGADDR((Reg),(Bit)))))
 Macro to access a single bit of a peripheral register (bit band region 0x40000000 to 0x400FFFFF) using the bit-band alias region access. Can be used for peripherals with 8bit access allowed. More...
 
#define NUMBER_OF_INT_VECTORS   102
 
#define __MPU_PRESENT   0
 
#define __NVIC_PRIO_BITS   4
 
#define __Vendor_SysTickConfig   0
 
#define __FPU_PRESENT   1
 
#define ADC0_BASE   (0x4003B000u)
 
#define ADC0   ((ADC_Type *)ADC0_BASE)
 
#define ADC1_BASE   (0x400BB000u)
 
#define ADC1   ((ADC_Type *)ADC1_BASE)
 
#define ADC_BASE_ADDRS   { ADC0_BASE, ADC1_BASE }
 
#define ADC_BASE_PTRS   { ADC0, ADC1 }
 
#define ADC_IRQS   { ADC0_IRQn, ADC1_IRQn }
 
#define AIPS0_BASE   (0x40000000u)
 
#define AIPS0   ((AIPS_Type *)AIPS0_BASE)
 
#define AIPS1_BASE   (0x40080000u)
 
#define AIPS1   ((AIPS_Type *)AIPS1_BASE)
 
#define AIPS_BASE_ADDRS   { AIPS0_BASE, AIPS1_BASE }
 
#define AIPS_BASE_PTRS   { AIPS0, AIPS1 }
 
#define AXBS_BASE   (0x40004000u)
 
#define AXBS   ((AXBS_Type *)AXBS_BASE)
 
#define AXBS_BASE_ADDRS   { AXBS_BASE }
 
#define AXBS_BASE_PTRS   { AXBS }
 
#define CAN0_BASE   (0x40024000u)
 
#define CAN0   ((CAN_Type *)CAN0_BASE)
 
#define CAN_BASE_ADDRS   { CAN0_BASE }
 
#define CAN_BASE_PTRS   { CAN0 }
 
#define CAN_Rx_Warning_IRQS   { CAN0_Rx_Warning_IRQn }
 
#define CAN_Tx_Warning_IRQS   { CAN0_Tx_Warning_IRQn }
 
#define CAN_Wake_Up_IRQS   { CAN0_Wake_Up_IRQn }
 
#define CAN_Error_IRQS   { CAN0_Error_IRQn }
 
#define CAN_Bus_Off_IRQS   { CAN0_Bus_Off_IRQn }
 
#define CAN_ORed_Message_buffer_IRQS   { CAN0_ORed_Message_buffer_IRQn }
 
#define CAU_BASE   (0xE0081000u)
 
#define CAU   ((CAU_Type *)CAU_BASE)
 
#define CAU_BASE_ADDRS   { CAU_BASE }
 
#define CAU_BASE_PTRS   { CAU }
 
#define CMP0_BASE   (0x40073000u)
 
#define CMP0   ((CMP_Type *)CMP0_BASE)
 
#define CMP1_BASE   (0x40073008u)
 
#define CMP1   ((CMP_Type *)CMP1_BASE)
 
#define CMP2_BASE   (0x40073010u)
 
#define CMP2   ((CMP_Type *)CMP2_BASE)
 
#define CMP_BASE_ADDRS   { CMP0_BASE, CMP1_BASE, CMP2_BASE }
 
#define CMP_BASE_PTRS   { CMP0, CMP1, CMP2 }
 
#define CMP_IRQS   { CMP0_IRQn, CMP1_IRQn, CMP2_IRQn }
 
#define CMT_BASE   (0x40062000u)
 
#define CMT   ((CMT_Type *)CMT_BASE)
 
#define CMT_BASE_ADDRS   { CMT_BASE }
 
#define CMT_BASE_PTRS   { CMT }
 
#define CMT_IRQS   { CMT_IRQn }
 
#define CRC_BASE   (0x40032000u)
 
#define CRC0   ((CRC_Type *)CRC_BASE)
 
#define CRC_BASE_ADDRS   { CRC_BASE }
 
#define CRC_BASE_PTRS   { CRC0 }
 
#define DAC0_BASE   (0x400CC000u)
 
#define DAC0   ((DAC_Type *)DAC0_BASE)
 
#define DAC1_BASE   (0x400CD000u)
 
#define DAC1   ((DAC_Type *)DAC1_BASE)
 
#define DAC_BASE_ADDRS   { DAC0_BASE, DAC1_BASE }
 
#define DAC_BASE_PTRS   { DAC0, DAC1 }
 
#define DAC_IRQS   { DAC0_IRQn, DAC1_IRQn }
 
#define DMA_BASE   (0x40008000u)
 
#define DMA0   ((DMA_Type *)DMA_BASE)
 
#define DMA_BASE_ADDRS   { DMA_BASE }
 
#define DMA_BASE_PTRS   { DMA0 }
 
#define DMA_CHN_IRQS   { { DMA0_IRQn, DMA1_IRQn, DMA2_IRQn, DMA3_IRQn, DMA4_IRQn, DMA5_IRQn, DMA6_IRQn, DMA7_IRQn, DMA8_IRQn, DMA9_IRQn, DMA10_IRQn, DMA11_IRQn, DMA12_IRQn, DMA13_IRQn, DMA14_IRQn, DMA15_IRQn } }
 
#define DMA_ERROR_IRQS   { DMA_Error_IRQn }
 
#define DMAMUX_BASE   (0x40021000u)
 
#define DMAMUX   ((DMAMUX_Type *)DMAMUX_BASE)
 
#define DMAMUX_BASE_ADDRS   { DMAMUX_BASE }
 
#define DMAMUX_BASE_PTRS   { DMAMUX }
 
#define ENET_BASE   (0x400C0000u)
 
#define ENET   ((ENET_Type *)ENET_BASE)
 
#define ENET_BASE_ADDRS   { ENET_BASE }
 
#define ENET_BASE_PTRS   { ENET }
 
#define ENET_Transmit_IRQS   { ENET_Transmit_IRQn }
 
#define ENET_Receive_IRQS   { ENET_Receive_IRQn }
 
#define ENET_Error_IRQS   { ENET_Error_IRQn }
 
#define ENET_1588_Timer_IRQS   { ENET_1588_Timer_IRQn }
 
#define ENET_BUFF_ALIGNMENT   (16U)
 
#define EWM_BASE   (0x40061000u)
 
#define EWM   ((EWM_Type *)EWM_BASE)
 
#define EWM_BASE_ADDRS   { EWM_BASE }
 
#define EWM_BASE_PTRS   { EWM }
 
#define EWM_IRQS   { WDOG_EWM_IRQn }
 
#define FB_BASE   (0x4000C000u)
 
#define FB   ((FB_Type *)FB_BASE)
 
#define FB_BASE_ADDRS   { FB_BASE }
 
#define FB_BASE_PTRS   { FB }
 
#define FMC_BASE   (0x4001F000u)
 
#define FMC   ((FMC_Type *)FMC_BASE)
 
#define FMC_BASE_ADDRS   { FMC_BASE }
 
#define FMC_BASE_PTRS   { FMC }
 
#define FTFE_BASE   (0x40020000u)
 
#define FTFE   ((FTFE_Type *)FTFE_BASE)
 
#define FTFE_BASE_ADDRS   { FTFE_BASE }
 
#define FTFE_BASE_PTRS   { FTFE }
 
#define FTFE_COMMAND_COMPLETE_IRQS   { FTFE_IRQn }
 
#define FTFE_READ_COLLISION_IRQS   { Read_Collision_IRQn }
 
#define FTM0_BASE   (0x40038000u)
 
#define FTM0   ((FTM_Type *)FTM0_BASE)
 
#define FTM1_BASE   (0x40039000u)
 
#define FTM1   ((FTM_Type *)FTM1_BASE)
 
#define FTM2_BASE   (0x4003A000u)
 
#define FTM2   ((FTM_Type *)FTM2_BASE)
 
#define FTM3_BASE   (0x400B9000u)
 
#define FTM3   ((FTM_Type *)FTM3_BASE)
 
#define FTM_BASE_ADDRS   { FTM0_BASE, FTM1_BASE, FTM2_BASE, FTM3_BASE }
 
#define FTM_BASE_PTRS   { FTM0, FTM1, FTM2, FTM3 }
 
#define FTM_IRQS   { FTM0_IRQn, FTM1_IRQn, FTM2_IRQn, FTM3_IRQn }
 
#define GPIOA_BASE   (0x400FF000u)
 
#define GPIOA   ((GPIO_Type *)GPIOA_BASE)
 
#define GPIOB_BASE   (0x400FF040u)
 
#define GPIOB   ((GPIO_Type *)GPIOB_BASE)
 
#define GPIOC_BASE   (0x400FF080u)
 
#define GPIOC   ((GPIO_Type *)GPIOC_BASE)
 
#define GPIOD_BASE   (0x400FF0C0u)
 
#define GPIOD   ((GPIO_Type *)GPIOD_BASE)
 
#define GPIOE_BASE   (0x400FF100u)
 
#define GPIOE   ((GPIO_Type *)GPIOE_BASE)
 
#define GPIO_BASE_ADDRS   { GPIOA_BASE, GPIOB_BASE, GPIOC_BASE, GPIOD_BASE, GPIOE_BASE }
 
#define GPIO_BASE_PTRS   { GPIOA, GPIOB, GPIOC, GPIOD, GPIOE }
 
#define I2C0_BASE   (0x40066000u)
 
#define I2C0   ((I2C_Type *)I2C0_BASE)
 
#define I2C1_BASE   (0x40067000u)
 
#define I2C1   ((I2C_Type *)I2C1_BASE)
 
#define I2C2_BASE   (0x400E6000u)
 
#define I2C2   ((I2C_Type *)I2C2_BASE)
 
#define I2C_BASE_ADDRS   { I2C0_BASE, I2C1_BASE, I2C2_BASE }
 
#define I2C_BASE_PTRS   { I2C0, I2C1, I2C2 }
 
#define I2C_IRQS   { I2C0_IRQn, I2C1_IRQn, I2C2_IRQn }
 
#define I2S0_BASE   (0x4002F000u)
 
#define I2S0   ((I2S_Type *)I2S0_BASE)
 
#define I2S_BASE_ADDRS   { I2S0_BASE }
 
#define I2S_BASE_PTRS   { I2S0 }
 
#define I2S_RX_IRQS   { I2S0_Rx_IRQn }
 
#define I2S_TX_IRQS   { I2S0_Tx_IRQn }
 
#define LLWU_BASE   (0x4007C000u)
 
#define LLWU   ((LLWU_Type *)LLWU_BASE)
 
#define LLWU_BASE_ADDRS   { LLWU_BASE }
 
#define LLWU_BASE_PTRS   { LLWU }
 
#define LLWU_IRQS   { LLWU_IRQn }
 
#define LPTMR0_BASE   (0x40040000u)
 
#define LPTMR0   ((LPTMR_Type *)LPTMR0_BASE)
 
#define LPTMR_BASE_ADDRS   { LPTMR0_BASE }
 
#define LPTMR_BASE_PTRS   { LPTMR0 }
 
#define LPTMR_IRQS   { LPTMR0_IRQn }
 
#define MCG_BASE   (0x40064000u)
 
#define MCG   ((MCG_Type *)MCG_BASE)
 
#define MCG_BASE_ADDRS   { MCG_BASE }
 
#define MCG_BASE_PTRS   { MCG }
 
#define MCM_BASE   (0xE0080000u)
 
#define MCM   ((MCM_Type *)MCM_BASE)
 
#define MCM_BASE_ADDRS   { MCM_BASE }
 
#define MCM_BASE_PTRS   { MCM }
 
#define MCM_IRQS   { MCM_IRQn }
 
#define FTFE_FlashConfig_BASE   (0x400u)
 
#define FTFE_FlashConfig   ((NV_Type *)FTFE_FlashConfig_BASE)
 
#define NV_BASE_ADDRS   { FTFE_FlashConfig_BASE }
 
#define NV_BASE_PTRS   { FTFE_FlashConfig }
 
#define OSC_BASE   (0x40065000u)
 
#define OSC   ((OSC_Type *)OSC_BASE)
 
#define OSC_BASE_ADDRS   { OSC_BASE }
 
#define OSC_BASE_PTRS   { OSC }
 
#define PDB0_BASE   (0x40036000u)
 
#define PDB0   ((PDB_Type *)PDB0_BASE)
 
#define PDB_BASE_ADDRS   { PDB0_BASE }
 
#define PDB_BASE_PTRS   { PDB0 }
 
#define PDB_IRQS   { PDB0_IRQn }
 
#define PIT_BASE   (0x40037000u)
 
#define PIT   ((PIT_Type *)PIT_BASE)
 
#define PIT_BASE_ADDRS   { PIT_BASE }
 
#define PIT_BASE_PTRS   { PIT }
 
#define PIT_IRQS   { { PIT0_IRQn, PIT1_IRQn, PIT2_IRQn, PIT3_IRQn } }
 
#define PMC_BASE   (0x4007D000u)
 
#define PMC   ((PMC_Type *)PMC_BASE)
 
#define PMC_BASE_ADDRS   { PMC_BASE }
 
#define PMC_BASE_PTRS   { PMC }
 
#define PMC_IRQS   { LVD_LVW_IRQn }
 
#define PORTA_BASE   (0x40049000u)
 
#define PORTA   ((PORT_Type *)PORTA_BASE)
 
#define PORTB_BASE   (0x4004A000u)
 
#define PORTB   ((PORT_Type *)PORTB_BASE)
 
#define PORTC_BASE   (0x4004B000u)
 
#define PORTC   ((PORT_Type *)PORTC_BASE)
 
#define PORTD_BASE   (0x4004C000u)
 
#define PORTD   ((PORT_Type *)PORTD_BASE)
 
#define PORTE_BASE   (0x4004D000u)
 
#define PORTE   ((PORT_Type *)PORTE_BASE)
 
#define PORT_BASE_ADDRS   { PORTA_BASE, PORTB_BASE, PORTC_BASE, PORTD_BASE, PORTE_BASE }
 
#define PORT_BASE_PTRS   { PORTA, PORTB, PORTC, PORTD, PORTE }
 
#define PORT_IRQS   { PORTA_IRQn, PORTB_IRQn, PORTC_IRQn, PORTD_IRQn, PORTE_IRQn }
 
#define RCM_BASE   (0x4007F000u)
 
#define RCM   ((RCM_Type *)RCM_BASE)
 
#define RCM_BASE_ADDRS   { RCM_BASE }
 
#define RCM_BASE_PTRS   { RCM }
 
#define RFSYS_BASE   (0x40041000u)
 
#define RFSYS   ((RFSYS_Type *)RFSYS_BASE)
 
#define RFSYS_BASE_ADDRS   { RFSYS_BASE }
 
#define RFSYS_BASE_PTRS   { RFSYS }
 
#define RFVBAT_BASE   (0x4003E000u)
 
#define RFVBAT   ((RFVBAT_Type *)RFVBAT_BASE)
 
#define RFVBAT_BASE_ADDRS   { RFVBAT_BASE }
 
#define RFVBAT_BASE_PTRS   { RFVBAT }
 
#define RNG_BASE   (0x40029000u)
 
#define RNG   ((RNG_Type *)RNG_BASE)
 
#define RNG_BASE_ADDRS   { RNG_BASE }
 
#define RNG_BASE_PTRS   { RNG }
 
#define RNG_IRQS   { RNG_IRQn }
 
#define RTC_BASE   (0x4003D000u)
 
#define RTC   ((RTC_Type *)RTC_BASE)
 
#define RTC_BASE_ADDRS   { RTC_BASE }
 
#define RTC_BASE_PTRS   { RTC }
 
#define RTC_IRQS   { RTC_IRQn }
 
#define RTC_SECONDS_IRQS   { RTC_Seconds_IRQn }
 
#define SDHC_BASE   (0x400B1000u)
 
#define SDHC   ((SDHC_Type *)SDHC_BASE)
 
#define SDHC_BASE_ADDRS   { SDHC_BASE }
 
#define SDHC_BASE_PTRS   { SDHC }
 
#define SDHC_IRQS   { SDHC_IRQn }
 
#define SIM_BASE   (0x40047000u)
 
#define SIM   ((SIM_Type *)SIM_BASE)
 
#define SIM_BASE_ADDRS   { SIM_BASE }
 
#define SIM_BASE_PTRS   { SIM }
 
#define SMC_BASE   (0x4007E000u)
 
#define SMC   ((SMC_Type *)SMC_BASE)
 
#define SMC_BASE_ADDRS   { SMC_BASE }
 
#define SMC_BASE_PTRS   { SMC }
 
#define SPI0_BASE   (0x4002C000u)
 
#define SPI0   ((SPI_Type *)SPI0_BASE)
 
#define SPI1_BASE   (0x4002D000u)
 
#define SPI1   ((SPI_Type *)SPI1_BASE)
 
#define SPI2_BASE   (0x400AC000u)
 
#define SPI2   ((SPI_Type *)SPI2_BASE)
 
#define SPI_BASE_ADDRS   { SPI0_BASE, SPI1_BASE, SPI2_BASE }
 
#define SPI_BASE_PTRS   { SPI0, SPI1, SPI2 }
 
#define SPI_IRQS   { SPI0_IRQn, SPI1_IRQn, SPI2_IRQn }
 
#define SYSMPU_BASE   (0x4000D000u)
 
#define SYSMPU   ((SYSMPU_Type *)SYSMPU_BASE)
 
#define SYSMPU_BASE_ADDRS   { SYSMPU_BASE }
 
#define SYSMPU_BASE_PTRS   { SYSMPU }
 
#define UART0_BASE   (0x4006A000u)
 
#define UART0   ((UART_Type *)UART0_BASE)
 
#define UART1_BASE   (0x4006B000u)
 
#define UART1   ((UART_Type *)UART1_BASE)
 
#define UART2_BASE   (0x4006C000u)
 
#define UART2   ((UART_Type *)UART2_BASE)
 
#define UART3_BASE   (0x4006D000u)
 
#define UART3   ((UART_Type *)UART3_BASE)
 
#define UART4_BASE   (0x400EA000u)
 
#define UART4   ((UART_Type *)UART4_BASE)
 
#define UART5_BASE   (0x400EB000u)
 
#define UART5   ((UART_Type *)UART5_BASE)
 
#define UART_BASE_ADDRS   { UART0_BASE, UART1_BASE, UART2_BASE, UART3_BASE, UART4_BASE, UART5_BASE }
 
#define UART_BASE_PTRS   { UART0, UART1, UART2, UART3, UART4, UART5 }
 
#define UART_RX_TX_IRQS   { UART0_RX_TX_IRQn, UART1_RX_TX_IRQn, UART2_RX_TX_IRQn, UART3_RX_TX_IRQn, UART4_RX_TX_IRQn, UART5_RX_TX_IRQn }
 
#define UART_ERR_IRQS   { UART0_ERR_IRQn, UART1_ERR_IRQn, UART2_ERR_IRQn, UART3_ERR_IRQn, UART4_ERR_IRQn, UART5_ERR_IRQn }
 
#define UART_LON_IRQS   { UART0_LON_IRQn, NotAvail_IRQn, NotAvail_IRQn, NotAvail_IRQn, NotAvail_IRQn, NotAvail_IRQn }
 
#define USB0_BASE   (0x40072000u)
 
#define USB0   ((USB_Type *)USB0_BASE)
 
#define USB_BASE_ADDRS   { USB0_BASE }
 
#define USB_BASE_PTRS   { USB0 }
 
#define USB_IRQS   { USB0_IRQn }
 
#define USBDCD_BASE   (0x40035000u)
 
#define USBDCD   ((USBDCD_Type *)USBDCD_BASE)
 
#define USBDCD_BASE_ADDRS   { USBDCD_BASE }
 
#define USBDCD_BASE_PTRS   { USBDCD }
 
#define USBDCD_IRQS   { USBDCD_IRQn }
 
#define VREF_BASE   (0x40074000u)
 
#define VREF   ((VREF_Type *)VREF_BASE)
 
#define VREF_BASE_ADDRS   { VREF_BASE }
 
#define VREF_BASE_PTRS   { VREF }
 
#define WDOG_BASE   (0x40052000u)
 
#define WDOG   ((WDOG_Type *)WDOG_BASE)
 
#define WDOG_BASE_ADDRS   { WDOG_BASE }
 
#define WDOG_BASE_PTRS   { WDOG }
 
#define WDOG_IRQS   { WDOG_EWM_IRQn }
 
#define NXP_VAL2FLD(field, value)   (((value) << (field ## _SHIFT)) & (field ## _MASK))
 Mask and left-shift a bit field value for use in a register bit range. More...
 
#define NXP_FLD2VAL(field, value)   (((value) & (field ## _MASK)) >> (field ## _SHIFT))
 Mask and right-shift a register value to extract a bit field value. More...
 
#define ENET_RMON_R_DROP_REG(base)   ENET_IEEE_R_DROP_REG(base)
 
#define ENET_RMON_R_FRAME_OK_REG(base)   ENET_IEEE_R_FRAME_OK_REG(base)
 
#define MCG_C2_EREFS0_MASK   MCG_C2_EREFS_MASK
 
#define MCG_C2_EREFS0_SHIFT   MCG_C2_EREFS_SHIFT
 
#define MCG_C2_HGO0_MASK   MCG_C2_HGO_MASK
 
#define MCG_C2_HGO0_SHIFT   MCG_C2_HGO_SHIFT
 
#define MCG_C2_RANGE0_MASK   MCG_C2_RANGE_MASK
 
#define MCG_C2_RANGE0_SHIFT   MCG_C2_RANGE_SHIFT
 
#define MCG_C2_RANGE0(x)   MCG_C2_RANGE(x)
 
#define MCM_ISR_REG(base)   MCM_ISCR_REG(base)
 
#define MCM_ISR_FIOC_MASK   MCM_ISCR_FIOC_MASK
 
#define MCM_ISR_FIOC_SHIFT   MCM_ISCR_FIOC_SHIFT
 
#define MCM_ISR_FDZC_MASK   MCM_ISCR_FDZC_MASK
 
#define MCM_ISR_FDZC_SHIFT   MCM_ISCR_FDZC_SHIFT
 
#define MCM_ISR_FOFC_MASK   MCM_ISCR_FOFC_MASK
 
#define MCM_ISR_FOFC_SHIFT   MCM_ISCR_FOFC_SHIFT
 
#define MCM_ISR_FUFC_MASK   MCM_ISCR_FUFC_MASK
 
#define MCM_ISR_FUFC_SHIFT   MCM_ISCR_FUFC_SHIFT
 
#define MCM_ISR_FIXC_MASK   MCM_ISCR_FIXC_MASK
 
#define MCM_ISR_FIXC_SHIFT   MCM_ISCR_FIXC_SHIFT
 
#define MCM_ISR_FIDC_MASK   MCM_ISCR_FIDC_MASK
 
#define MCM_ISR_FIDC_SHIFT   MCM_ISCR_FIDC_SHIFT
 
#define MCM_ISR_FIOCE_MASK   MCM_ISCR_FIOCE_MASK
 
#define MCM_ISR_FIOCE_SHIFT   MCM_ISCR_FIOCE_SHIFT
 
#define MCM_ISR_FDZCE_MASK   MCM_ISCR_FDZCE_MASK
 
#define MCM_ISR_FDZCE_SHIFT   MCM_ISCR_FDZCE_SHIFT
 
#define MCM_ISR_FOFCE_MASK   MCM_ISCR_FOFCE_MASK
 
#define MCM_ISR_FOFCE_SHIFT   MCM_ISCR_FOFCE_SHIFT
 
#define MCM_ISR_FUFCE_MASK   MCM_ISCR_FUFCE_MASK
 
#define MCM_ISR_FUFCE_SHIFT   MCM_ISCR_FUFCE_SHIFT
 
#define MCM_ISR_FIXCE_MASK   MCM_ISCR_FIXCE_MASK
 
#define MCM_ISR_FIXCE_SHIFT   MCM_ISCR_FIXCE_SHIFT
 
#define MCM_ISR_FIDCE_MASK   MCM_ISCR_FIDCE_MASK
 
#define MCM_ISR_FIDCE_SHIFT   MCM_ISCR_FIDCE_SHIFT
 
#define DSPI0   SPI0
 
#define DSPI1   SPI1
 
#define DSPI2   SPI2
 
#define FLEXCAN0   CAN0
 
#define PTA_BASE   GPIOA_BASE
 
#define PTA   GPIOA
 
#define PTB_BASE   GPIOB_BASE
 
#define PTB   GPIOB
 
#define PTC_BASE   GPIOC_BASE
 
#define PTC   GPIOC
 
#define PTD_BASE   GPIOD_BASE
 
#define PTD   GPIOD
 
#define PTE_BASE   GPIOE_BASE
 
#define PTE   GPIOE
 
#define UART_WP7816_T_TYPE0_REG(base)   UART_WP7816T0_REG(base)
 
#define UART_WP7816_T_TYPE1_REG(base)   UART_WP7816T1_REG(base)
 
#define UART_WP7816_T_TYPE0_WI_MASK   UART_WP7816T0_WI_MASK
 
#define UART_WP7816_T_TYPE0_WI_SHIFT   UART_WP7816T0_WI_SHIFT
 
#define UART_WP7816_T_TYPE0_WI(x)   UART_WP7816T0_WI(x)
 
#define UART_WP7816_T_TYPE1_BWI_MASK   UART_WP7816T1_BWI_MASK
 
#define UART_WP7816_T_TYPE1_BWI_SHIFT   UART_WP7816T1_BWI_SHIFT
 
#define UART_WP7816_T_TYPE1_BWI(x)   UART_WP7816T1_BWI(x)
 
#define UART_WP7816_T_TYPE1_CWI_MASK   UART_WP7816T1_CWI_MASK
 
#define UART_WP7816_T_TYPE1_CWI_SHIFT   UART_WP7816T1_CWI_SHIFT
 
#define UART_WP7816_T_TYPE1_CWI(x)   UART_WP7816T1_CWI(x)
 
#define Watchdog_IRQn   WDOG_EWM_IRQn
 
#define Watchdog_IRQHandler   WDOG_EWM_IRQHandler
 
#define LPTimer_IRQn   LPTMR0_IRQn
 
#define LPTimer_IRQHandler   LPTMR0_IRQHandler
 
#define LLW_IRQn   LLWU_IRQn
 
#define LLW_IRQHandler   LLWU_IRQHandler
 
#define DMAMUX0   DMAMUX
 
#define WDOG0   WDOG
 
#define MCM0   MCM
 
#define RTC0   RTC
 
SC1 - ADC Status and Control Registers 1
#define ADC_SC1_ADCH_MASK   (0x1FU)
 
#define ADC_SC1_ADCH_SHIFT   (0U)
 
#define ADC_SC1_ADCH(x)   (((uint32_t)(((uint32_t)(x)) << ADC_SC1_ADCH_SHIFT)) & ADC_SC1_ADCH_MASK)
 
#define ADC_SC1_DIFF_MASK   (0x20U)
 
#define ADC_SC1_DIFF_SHIFT   (5U)
 
#define ADC_SC1_DIFF(x)   (((uint32_t)(((uint32_t)(x)) << ADC_SC1_DIFF_SHIFT)) & ADC_SC1_DIFF_MASK)
 
#define ADC_SC1_AIEN_MASK   (0x40U)
 
#define ADC_SC1_AIEN_SHIFT   (6U)
 
#define ADC_SC1_AIEN(x)   (((uint32_t)(((uint32_t)(x)) << ADC_SC1_AIEN_SHIFT)) & ADC_SC1_AIEN_MASK)
 
#define ADC_SC1_COCO_MASK   (0x80U)
 
#define ADC_SC1_COCO_SHIFT   (7U)
 
#define ADC_SC1_COCO(x)   (((uint32_t)(((uint32_t)(x)) << ADC_SC1_COCO_SHIFT)) & ADC_SC1_COCO_MASK)
 
#define ADC_SC1_COUNT   (2U)
 
CFG1 - ADC Configuration Register 1
#define ADC_CFG1_ADICLK_MASK   (0x3U)
 
#define ADC_CFG1_ADICLK_SHIFT   (0U)
 
#define ADC_CFG1_ADICLK(x)   (((uint32_t)(((uint32_t)(x)) << ADC_CFG1_ADICLK_SHIFT)) & ADC_CFG1_ADICLK_MASK)
 
#define ADC_CFG1_MODE_MASK   (0xCU)
 
#define ADC_CFG1_MODE_SHIFT   (2U)
 
#define ADC_CFG1_MODE(x)   (((uint32_t)(((uint32_t)(x)) << ADC_CFG1_MODE_SHIFT)) & ADC_CFG1_MODE_MASK)
 
#define ADC_CFG1_ADLSMP_MASK   (0x10U)
 
#define ADC_CFG1_ADLSMP_SHIFT   (4U)
 
#define ADC_CFG1_ADLSMP(x)   (((uint32_t)(((uint32_t)(x)) << ADC_CFG1_ADLSMP_SHIFT)) & ADC_CFG1_ADLSMP_MASK)
 
#define ADC_CFG1_ADIV_MASK   (0x60U)
 
#define ADC_CFG1_ADIV_SHIFT   (5U)
 
#define ADC_CFG1_ADIV(x)   (((uint32_t)(((uint32_t)(x)) << ADC_CFG1_ADIV_SHIFT)) & ADC_CFG1_ADIV_MASK)
 
#define ADC_CFG1_ADLPC_MASK   (0x80U)
 
#define ADC_CFG1_ADLPC_SHIFT   (7U)
 
#define ADC_CFG1_ADLPC(x)   (((uint32_t)(((uint32_t)(x)) << ADC_CFG1_ADLPC_SHIFT)) & ADC_CFG1_ADLPC_MASK)
 
CFG2 - ADC Configuration Register 2
#define ADC_CFG2_ADLSTS_MASK   (0x3U)
 
#define ADC_CFG2_ADLSTS_SHIFT   (0U)
 
#define ADC_CFG2_ADLSTS(x)   (((uint32_t)(((uint32_t)(x)) << ADC_CFG2_ADLSTS_SHIFT)) & ADC_CFG2_ADLSTS_MASK)
 
#define ADC_CFG2_ADHSC_MASK   (0x4U)
 
#define ADC_CFG2_ADHSC_SHIFT   (2U)
 
#define ADC_CFG2_ADHSC(x)   (((uint32_t)(((uint32_t)(x)) << ADC_CFG2_ADHSC_SHIFT)) & ADC_CFG2_ADHSC_MASK)
 
#define ADC_CFG2_ADACKEN_MASK   (0x8U)
 
#define ADC_CFG2_ADACKEN_SHIFT   (3U)
 
#define ADC_CFG2_ADACKEN(x)   (((uint32_t)(((uint32_t)(x)) << ADC_CFG2_ADACKEN_SHIFT)) & ADC_CFG2_ADACKEN_MASK)
 
#define ADC_CFG2_MUXSEL_MASK   (0x10U)
 
#define ADC_CFG2_MUXSEL_SHIFT   (4U)
 
#define ADC_CFG2_MUXSEL(x)   (((uint32_t)(((uint32_t)(x)) << ADC_CFG2_MUXSEL_SHIFT)) & ADC_CFG2_MUXSEL_MASK)
 
R - ADC Data Result Register
#define ADC_R_D_MASK   (0xFFFFU)
 
#define ADC_R_D_SHIFT   (0U)
 
#define ADC_R_D(x)   (((uint32_t)(((uint32_t)(x)) << ADC_R_D_SHIFT)) & ADC_R_D_MASK)
 
#define ADC_R_COUNT   (2U)
 
CV1 - Compare Value Registers
#define ADC_CV1_CV_MASK   (0xFFFFU)
 
#define ADC_CV1_CV_SHIFT   (0U)
 
#define ADC_CV1_CV(x)   (((uint32_t)(((uint32_t)(x)) << ADC_CV1_CV_SHIFT)) & ADC_CV1_CV_MASK)
 
CV2 - Compare Value Registers
#define ADC_CV2_CV_MASK   (0xFFFFU)
 
#define ADC_CV2_CV_SHIFT   (0U)
 
#define ADC_CV2_CV(x)   (((uint32_t)(((uint32_t)(x)) << ADC_CV2_CV_SHIFT)) & ADC_CV2_CV_MASK)
 
SC2 - Status and Control Register 2
#define ADC_SC2_REFSEL_MASK   (0x3U)
 
#define ADC_SC2_REFSEL_SHIFT   (0U)
 
#define ADC_SC2_REFSEL(x)   (((uint32_t)(((uint32_t)(x)) << ADC_SC2_REFSEL_SHIFT)) & ADC_SC2_REFSEL_MASK)
 
#define ADC_SC2_DMAEN_MASK   (0x4U)
 
#define ADC_SC2_DMAEN_SHIFT   (2U)
 
#define ADC_SC2_DMAEN(x)   (((uint32_t)(((uint32_t)(x)) << ADC_SC2_DMAEN_SHIFT)) & ADC_SC2_DMAEN_MASK)
 
#define ADC_SC2_ACREN_MASK   (0x8U)
 
#define ADC_SC2_ACREN_SHIFT   (3U)
 
#define ADC_SC2_ACREN(x)   (((uint32_t)(((uint32_t)(x)) << ADC_SC2_ACREN_SHIFT)) & ADC_SC2_ACREN_MASK)
 
#define ADC_SC2_ACFGT_MASK   (0x10U)
 
#define ADC_SC2_ACFGT_SHIFT   (4U)
 
#define ADC_SC2_ACFGT(x)   (((uint32_t)(((uint32_t)(x)) << ADC_SC2_ACFGT_SHIFT)) & ADC_SC2_ACFGT_MASK)
 
#define ADC_SC2_ACFE_MASK   (0x20U)
 
#define ADC_SC2_ACFE_SHIFT   (5U)
 
#define ADC_SC2_ACFE(x)   (((uint32_t)(((uint32_t)(x)) << ADC_SC2_ACFE_SHIFT)) & ADC_SC2_ACFE_MASK)
 
#define ADC_SC2_ADTRG_MASK   (0x40U)
 
#define ADC_SC2_ADTRG_SHIFT   (6U)
 
#define ADC_SC2_ADTRG(x)   (((uint32_t)(((uint32_t)(x)) << ADC_SC2_ADTRG_SHIFT)) & ADC_SC2_ADTRG_MASK)
 
#define ADC_SC2_ADACT_MASK   (0x80U)
 
#define ADC_SC2_ADACT_SHIFT   (7U)
 
#define ADC_SC2_ADACT(x)   (((uint32_t)(((uint32_t)(x)) << ADC_SC2_ADACT_SHIFT)) & ADC_SC2_ADACT_MASK)
 
SC3 - Status and Control Register 3
#define ADC_SC3_AVGS_MASK   (0x3U)
 
#define ADC_SC3_AVGS_SHIFT   (0U)
 
#define ADC_SC3_AVGS(x)   (((uint32_t)(((uint32_t)(x)) << ADC_SC3_AVGS_SHIFT)) & ADC_SC3_AVGS_MASK)
 
#define ADC_SC3_AVGE_MASK   (0x4U)
 
#define ADC_SC3_AVGE_SHIFT   (2U)
 
#define ADC_SC3_AVGE(x)   (((uint32_t)(((uint32_t)(x)) << ADC_SC3_AVGE_SHIFT)) & ADC_SC3_AVGE_MASK)
 
#define ADC_SC3_ADCO_MASK   (0x8U)
 
#define ADC_SC3_ADCO_SHIFT   (3U)
 
#define ADC_SC3_ADCO(x)   (((uint32_t)(((uint32_t)(x)) << ADC_SC3_ADCO_SHIFT)) & ADC_SC3_ADCO_MASK)
 
#define ADC_SC3_CALF_MASK   (0x40U)
 
#define ADC_SC3_CALF_SHIFT   (6U)
 
#define ADC_SC3_CALF(x)   (((uint32_t)(((uint32_t)(x)) << ADC_SC3_CALF_SHIFT)) & ADC_SC3_CALF_MASK)
 
#define ADC_SC3_CAL_MASK   (0x80U)
 
#define ADC_SC3_CAL_SHIFT   (7U)
 
#define ADC_SC3_CAL(x)   (((uint32_t)(((uint32_t)(x)) << ADC_SC3_CAL_SHIFT)) & ADC_SC3_CAL_MASK)
 
OFS - ADC Offset Correction Register
#define ADC_OFS_OFS_MASK   (0xFFFFU)
 
#define ADC_OFS_OFS_SHIFT   (0U)
 
#define ADC_OFS_OFS(x)   (((uint32_t)(((uint32_t)(x)) << ADC_OFS_OFS_SHIFT)) & ADC_OFS_OFS_MASK)
 
PG - ADC Plus-Side Gain Register
#define ADC_PG_PG_MASK   (0xFFFFU)
 
#define ADC_PG_PG_SHIFT   (0U)
 
#define ADC_PG_PG(x)   (((uint32_t)(((uint32_t)(x)) << ADC_PG_PG_SHIFT)) & ADC_PG_PG_MASK)
 
MG - ADC Minus-Side Gain Register
#define ADC_MG_MG_MASK   (0xFFFFU)
 
#define ADC_MG_MG_SHIFT   (0U)
 
#define ADC_MG_MG(x)   (((uint32_t)(((uint32_t)(x)) << ADC_MG_MG_SHIFT)) & ADC_MG_MG_MASK)
 
CLPD - ADC Plus-Side General Calibration Value Register
#define ADC_CLPD_CLPD_MASK   (0x3FU)
 
#define ADC_CLPD_CLPD_SHIFT   (0U)
 
#define ADC_CLPD_CLPD(x)   (((uint32_t)(((uint32_t)(x)) << ADC_CLPD_CLPD_SHIFT)) & ADC_CLPD_CLPD_MASK)
 
CLPS - ADC Plus-Side General Calibration Value Register
#define ADC_CLPS_CLPS_MASK   (0x3FU)
 
#define ADC_CLPS_CLPS_SHIFT   (0U)
 
#define ADC_CLPS_CLPS(x)   (((uint32_t)(((uint32_t)(x)) << ADC_CLPS_CLPS_SHIFT)) & ADC_CLPS_CLPS_MASK)
 
CLP4 - ADC Plus-Side General Calibration Value Register
#define ADC_CLP4_CLP4_MASK   (0x3FFU)
 
#define ADC_CLP4_CLP4_SHIFT   (0U)
 
#define ADC_CLP4_CLP4(x)   (((uint32_t)(((uint32_t)(x)) << ADC_CLP4_CLP4_SHIFT)) & ADC_CLP4_CLP4_MASK)
 
CLP3 - ADC Plus-Side General Calibration Value Register
#define ADC_CLP3_CLP3_MASK   (0x1FFU)
 
#define ADC_CLP3_CLP3_SHIFT   (0U)
 
#define ADC_CLP3_CLP3(x)   (((uint32_t)(((uint32_t)(x)) << ADC_CLP3_CLP3_SHIFT)) & ADC_CLP3_CLP3_MASK)
 
CLP2 - ADC Plus-Side General Calibration Value Register
#define ADC_CLP2_CLP2_MASK   (0xFFU)
 
#define ADC_CLP2_CLP2_SHIFT   (0U)
 
#define ADC_CLP2_CLP2(x)   (((uint32_t)(((uint32_t)(x)) << ADC_CLP2_CLP2_SHIFT)) & ADC_CLP2_CLP2_MASK)
 
CLP1 - ADC Plus-Side General Calibration Value Register
#define ADC_CLP1_CLP1_MASK   (0x7FU)
 
#define ADC_CLP1_CLP1_SHIFT   (0U)
 
#define ADC_CLP1_CLP1(x)   (((uint32_t)(((uint32_t)(x)) << ADC_CLP1_CLP1_SHIFT)) & ADC_CLP1_CLP1_MASK)
 
CLP0 - ADC Plus-Side General Calibration Value Register
#define ADC_CLP0_CLP0_MASK   (0x3FU)
 
#define ADC_CLP0_CLP0_SHIFT   (0U)
 
#define ADC_CLP0_CLP0(x)   (((uint32_t)(((uint32_t)(x)) << ADC_CLP0_CLP0_SHIFT)) & ADC_CLP0_CLP0_MASK)
 
CLMD - ADC Minus-Side General Calibration Value Register
#define ADC_CLMD_CLMD_MASK   (0x3FU)
 
#define ADC_CLMD_CLMD_SHIFT   (0U)
 
#define ADC_CLMD_CLMD(x)   (((uint32_t)(((uint32_t)(x)) << ADC_CLMD_CLMD_SHIFT)) & ADC_CLMD_CLMD_MASK)
 
CLMS - ADC Minus-Side General Calibration Value Register
#define ADC_CLMS_CLMS_MASK   (0x3FU)
 
#define ADC_CLMS_CLMS_SHIFT   (0U)
 
#define ADC_CLMS_CLMS(x)   (((uint32_t)(((uint32_t)(x)) << ADC_CLMS_CLMS_SHIFT)) & ADC_CLMS_CLMS_MASK)
 
CLM4 - ADC Minus-Side General Calibration Value Register
#define ADC_CLM4_CLM4_MASK   (0x3FFU)
 
#define ADC_CLM4_CLM4_SHIFT   (0U)
 
#define ADC_CLM4_CLM4(x)   (((uint32_t)(((uint32_t)(x)) << ADC_CLM4_CLM4_SHIFT)) & ADC_CLM4_CLM4_MASK)
 
CLM3 - ADC Minus-Side General Calibration Value Register
#define ADC_CLM3_CLM3_MASK   (0x1FFU)
 
#define ADC_CLM3_CLM3_SHIFT   (0U)
 
#define ADC_CLM3_CLM3(x)   (((uint32_t)(((uint32_t)(x)) << ADC_CLM3_CLM3_SHIFT)) & ADC_CLM3_CLM3_MASK)
 
CLM2 - ADC Minus-Side General Calibration Value Register
#define ADC_CLM2_CLM2_MASK   (0xFFU)
 
#define ADC_CLM2_CLM2_SHIFT   (0U)
 
#define ADC_CLM2_CLM2(x)   (((uint32_t)(((uint32_t)(x)) << ADC_CLM2_CLM2_SHIFT)) & ADC_CLM2_CLM2_MASK)
 
CLM1 - ADC Minus-Side General Calibration Value Register
#define ADC_CLM1_CLM1_MASK   (0x7FU)
 
#define ADC_CLM1_CLM1_SHIFT   (0U)
 
#define ADC_CLM1_CLM1(x)   (((uint32_t)(((uint32_t)(x)) << ADC_CLM1_CLM1_SHIFT)) & ADC_CLM1_CLM1_MASK)
 
CLM0 - ADC Minus-Side General Calibration Value Register
#define ADC_CLM0_CLM0_MASK   (0x3FU)
 
#define ADC_CLM0_CLM0_SHIFT   (0U)
 
#define ADC_CLM0_CLM0(x)   (((uint32_t)(((uint32_t)(x)) << ADC_CLM0_CLM0_SHIFT)) & ADC_CLM0_CLM0_MASK)
 
MPRA - Master Privilege Register A
#define AIPS_MPRA_MPL5_MASK   (0x100U)
 
#define AIPS_MPRA_MPL5_SHIFT   (8U)
 
#define AIPS_MPRA_MPL5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_MPRA_MPL5_SHIFT)) & AIPS_MPRA_MPL5_MASK)
 
#define AIPS_MPRA_MTW5_MASK   (0x200U)
 
#define AIPS_MPRA_MTW5_SHIFT   (9U)
 
#define AIPS_MPRA_MTW5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_MPRA_MTW5_SHIFT)) & AIPS_MPRA_MTW5_MASK)
 
#define AIPS_MPRA_MTR5_MASK   (0x400U)
 
#define AIPS_MPRA_MTR5_SHIFT   (10U)
 
#define AIPS_MPRA_MTR5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_MPRA_MTR5_SHIFT)) & AIPS_MPRA_MTR5_MASK)
 
#define AIPS_MPRA_MPL4_MASK   (0x1000U)
 
#define AIPS_MPRA_MPL4_SHIFT   (12U)
 
#define AIPS_MPRA_MPL4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_MPRA_MPL4_SHIFT)) & AIPS_MPRA_MPL4_MASK)
 
#define AIPS_MPRA_MTW4_MASK   (0x2000U)
 
#define AIPS_MPRA_MTW4_SHIFT   (13U)
 
#define AIPS_MPRA_MTW4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_MPRA_MTW4_SHIFT)) & AIPS_MPRA_MTW4_MASK)
 
#define AIPS_MPRA_MTR4_MASK   (0x4000U)
 
#define AIPS_MPRA_MTR4_SHIFT   (14U)
 
#define AIPS_MPRA_MTR4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_MPRA_MTR4_SHIFT)) & AIPS_MPRA_MTR4_MASK)
 
#define AIPS_MPRA_MPL3_MASK   (0x10000U)
 
#define AIPS_MPRA_MPL3_SHIFT   (16U)
 
#define AIPS_MPRA_MPL3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_MPRA_MPL3_SHIFT)) & AIPS_MPRA_MPL3_MASK)
 
#define AIPS_MPRA_MTW3_MASK   (0x20000U)
 
#define AIPS_MPRA_MTW3_SHIFT   (17U)
 
#define AIPS_MPRA_MTW3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_MPRA_MTW3_SHIFT)) & AIPS_MPRA_MTW3_MASK)
 
#define AIPS_MPRA_MTR3_MASK   (0x40000U)
 
#define AIPS_MPRA_MTR3_SHIFT   (18U)
 
#define AIPS_MPRA_MTR3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_MPRA_MTR3_SHIFT)) & AIPS_MPRA_MTR3_MASK)
 
#define AIPS_MPRA_MPL2_MASK   (0x100000U)
 
#define AIPS_MPRA_MPL2_SHIFT   (20U)
 
#define AIPS_MPRA_MPL2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_MPRA_MPL2_SHIFT)) & AIPS_MPRA_MPL2_MASK)
 
#define AIPS_MPRA_MTW2_MASK   (0x200000U)
 
#define AIPS_MPRA_MTW2_SHIFT   (21U)
 
#define AIPS_MPRA_MTW2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_MPRA_MTW2_SHIFT)) & AIPS_MPRA_MTW2_MASK)
 
#define AIPS_MPRA_MTR2_MASK   (0x400000U)
 
#define AIPS_MPRA_MTR2_SHIFT   (22U)
 
#define AIPS_MPRA_MTR2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_MPRA_MTR2_SHIFT)) & AIPS_MPRA_MTR2_MASK)
 
#define AIPS_MPRA_MPL1_MASK   (0x1000000U)
 
#define AIPS_MPRA_MPL1_SHIFT   (24U)
 
#define AIPS_MPRA_MPL1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_MPRA_MPL1_SHIFT)) & AIPS_MPRA_MPL1_MASK)
 
#define AIPS_MPRA_MTW1_MASK   (0x2000000U)
 
#define AIPS_MPRA_MTW1_SHIFT   (25U)
 
#define AIPS_MPRA_MTW1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_MPRA_MTW1_SHIFT)) & AIPS_MPRA_MTW1_MASK)
 
#define AIPS_MPRA_MTR1_MASK   (0x4000000U)
 
#define AIPS_MPRA_MTR1_SHIFT   (26U)
 
#define AIPS_MPRA_MTR1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_MPRA_MTR1_SHIFT)) & AIPS_MPRA_MTR1_MASK)
 
#define AIPS_MPRA_MPL0_MASK   (0x10000000U)
 
#define AIPS_MPRA_MPL0_SHIFT   (28U)
 
#define AIPS_MPRA_MPL0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_MPRA_MPL0_SHIFT)) & AIPS_MPRA_MPL0_MASK)
 
#define AIPS_MPRA_MTW0_MASK   (0x20000000U)
 
#define AIPS_MPRA_MTW0_SHIFT   (29U)
 
#define AIPS_MPRA_MTW0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_MPRA_MTW0_SHIFT)) & AIPS_MPRA_MTW0_MASK)
 
#define AIPS_MPRA_MTR0_MASK   (0x40000000U)
 
#define AIPS_MPRA_MTR0_SHIFT   (30U)
 
#define AIPS_MPRA_MTR0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_MPRA_MTR0_SHIFT)) & AIPS_MPRA_MTR0_MASK)
 
PACRA - Peripheral Access Control Register
#define AIPS_PACRA_TP7_MASK   (0x1U)
 
#define AIPS_PACRA_TP7_SHIFT   (0U)
 
#define AIPS_PACRA_TP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRA_TP7_SHIFT)) & AIPS_PACRA_TP7_MASK)
 
#define AIPS_PACRA_WP7_MASK   (0x2U)
 
#define AIPS_PACRA_WP7_SHIFT   (1U)
 
#define AIPS_PACRA_WP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRA_WP7_SHIFT)) & AIPS_PACRA_WP7_MASK)
 
#define AIPS_PACRA_SP7_MASK   (0x4U)
 
#define AIPS_PACRA_SP7_SHIFT   (2U)
 
#define AIPS_PACRA_SP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRA_SP7_SHIFT)) & AIPS_PACRA_SP7_MASK)
 
#define AIPS_PACRA_TP6_MASK   (0x10U)
 
#define AIPS_PACRA_TP6_SHIFT   (4U)
 
#define AIPS_PACRA_TP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRA_TP6_SHIFT)) & AIPS_PACRA_TP6_MASK)
 
#define AIPS_PACRA_WP6_MASK   (0x20U)
 
#define AIPS_PACRA_WP6_SHIFT   (5U)
 
#define AIPS_PACRA_WP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRA_WP6_SHIFT)) & AIPS_PACRA_WP6_MASK)
 
#define AIPS_PACRA_SP6_MASK   (0x40U)
 
#define AIPS_PACRA_SP6_SHIFT   (6U)
 
#define AIPS_PACRA_SP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRA_SP6_SHIFT)) & AIPS_PACRA_SP6_MASK)
 
#define AIPS_PACRA_TP5_MASK   (0x100U)
 
#define AIPS_PACRA_TP5_SHIFT   (8U)
 
#define AIPS_PACRA_TP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRA_TP5_SHIFT)) & AIPS_PACRA_TP5_MASK)
 
#define AIPS_PACRA_WP5_MASK   (0x200U)
 
#define AIPS_PACRA_WP5_SHIFT   (9U)
 
#define AIPS_PACRA_WP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRA_WP5_SHIFT)) & AIPS_PACRA_WP5_MASK)
 
#define AIPS_PACRA_SP5_MASK   (0x400U)
 
#define AIPS_PACRA_SP5_SHIFT   (10U)
 
#define AIPS_PACRA_SP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRA_SP5_SHIFT)) & AIPS_PACRA_SP5_MASK)
 
#define AIPS_PACRA_TP4_MASK   (0x1000U)
 
#define AIPS_PACRA_TP4_SHIFT   (12U)
 
#define AIPS_PACRA_TP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRA_TP4_SHIFT)) & AIPS_PACRA_TP4_MASK)
 
#define AIPS_PACRA_WP4_MASK   (0x2000U)
 
#define AIPS_PACRA_WP4_SHIFT   (13U)
 
#define AIPS_PACRA_WP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRA_WP4_SHIFT)) & AIPS_PACRA_WP4_MASK)
 
#define AIPS_PACRA_SP4_MASK   (0x4000U)
 
#define AIPS_PACRA_SP4_SHIFT   (14U)
 
#define AIPS_PACRA_SP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRA_SP4_SHIFT)) & AIPS_PACRA_SP4_MASK)
 
#define AIPS_PACRA_TP3_MASK   (0x10000U)
 
#define AIPS_PACRA_TP3_SHIFT   (16U)
 
#define AIPS_PACRA_TP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRA_TP3_SHIFT)) & AIPS_PACRA_TP3_MASK)
 
#define AIPS_PACRA_WP3_MASK   (0x20000U)
 
#define AIPS_PACRA_WP3_SHIFT   (17U)
 
#define AIPS_PACRA_WP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRA_WP3_SHIFT)) & AIPS_PACRA_WP3_MASK)
 
#define AIPS_PACRA_SP3_MASK   (0x40000U)
 
#define AIPS_PACRA_SP3_SHIFT   (18U)
 
#define AIPS_PACRA_SP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRA_SP3_SHIFT)) & AIPS_PACRA_SP3_MASK)
 
#define AIPS_PACRA_TP2_MASK   (0x100000U)
 
#define AIPS_PACRA_TP2_SHIFT   (20U)
 
#define AIPS_PACRA_TP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRA_TP2_SHIFT)) & AIPS_PACRA_TP2_MASK)
 
#define AIPS_PACRA_WP2_MASK   (0x200000U)
 
#define AIPS_PACRA_WP2_SHIFT   (21U)
 
#define AIPS_PACRA_WP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRA_WP2_SHIFT)) & AIPS_PACRA_WP2_MASK)
 
#define AIPS_PACRA_SP2_MASK   (0x400000U)
 
#define AIPS_PACRA_SP2_SHIFT   (22U)
 
#define AIPS_PACRA_SP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRA_SP2_SHIFT)) & AIPS_PACRA_SP2_MASK)
 
#define AIPS_PACRA_TP1_MASK   (0x1000000U)
 
#define AIPS_PACRA_TP1_SHIFT   (24U)
 
#define AIPS_PACRA_TP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRA_TP1_SHIFT)) & AIPS_PACRA_TP1_MASK)
 
#define AIPS_PACRA_WP1_MASK   (0x2000000U)
 
#define AIPS_PACRA_WP1_SHIFT   (25U)
 
#define AIPS_PACRA_WP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRA_WP1_SHIFT)) & AIPS_PACRA_WP1_MASK)
 
#define AIPS_PACRA_SP1_MASK   (0x4000000U)
 
#define AIPS_PACRA_SP1_SHIFT   (26U)
 
#define AIPS_PACRA_SP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRA_SP1_SHIFT)) & AIPS_PACRA_SP1_MASK)
 
#define AIPS_PACRA_TP0_MASK   (0x10000000U)
 
#define AIPS_PACRA_TP0_SHIFT   (28U)
 
#define AIPS_PACRA_TP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRA_TP0_SHIFT)) & AIPS_PACRA_TP0_MASK)
 
#define AIPS_PACRA_WP0_MASK   (0x20000000U)
 
#define AIPS_PACRA_WP0_SHIFT   (29U)
 
#define AIPS_PACRA_WP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRA_WP0_SHIFT)) & AIPS_PACRA_WP0_MASK)
 
#define AIPS_PACRA_SP0_MASK   (0x40000000U)
 
#define AIPS_PACRA_SP0_SHIFT   (30U)
 
#define AIPS_PACRA_SP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRA_SP0_SHIFT)) & AIPS_PACRA_SP0_MASK)
 
PACRB - Peripheral Access Control Register
#define AIPS_PACRB_TP7_MASK   (0x1U)
 
#define AIPS_PACRB_TP7_SHIFT   (0U)
 
#define AIPS_PACRB_TP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRB_TP7_SHIFT)) & AIPS_PACRB_TP7_MASK)
 
#define AIPS_PACRB_WP7_MASK   (0x2U)
 
#define AIPS_PACRB_WP7_SHIFT   (1U)
 
#define AIPS_PACRB_WP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRB_WP7_SHIFT)) & AIPS_PACRB_WP7_MASK)
 
#define AIPS_PACRB_SP7_MASK   (0x4U)
 
#define AIPS_PACRB_SP7_SHIFT   (2U)
 
#define AIPS_PACRB_SP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRB_SP7_SHIFT)) & AIPS_PACRB_SP7_MASK)
 
#define AIPS_PACRB_TP6_MASK   (0x10U)
 
#define AIPS_PACRB_TP6_SHIFT   (4U)
 
#define AIPS_PACRB_TP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRB_TP6_SHIFT)) & AIPS_PACRB_TP6_MASK)
 
#define AIPS_PACRB_WP6_MASK   (0x20U)
 
#define AIPS_PACRB_WP6_SHIFT   (5U)
 
#define AIPS_PACRB_WP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRB_WP6_SHIFT)) & AIPS_PACRB_WP6_MASK)
 
#define AIPS_PACRB_SP6_MASK   (0x40U)
 
#define AIPS_PACRB_SP6_SHIFT   (6U)
 
#define AIPS_PACRB_SP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRB_SP6_SHIFT)) & AIPS_PACRB_SP6_MASK)
 
#define AIPS_PACRB_TP5_MASK   (0x100U)
 
#define AIPS_PACRB_TP5_SHIFT   (8U)
 
#define AIPS_PACRB_TP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRB_TP5_SHIFT)) & AIPS_PACRB_TP5_MASK)
 
#define AIPS_PACRB_WP5_MASK   (0x200U)
 
#define AIPS_PACRB_WP5_SHIFT   (9U)
 
#define AIPS_PACRB_WP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRB_WP5_SHIFT)) & AIPS_PACRB_WP5_MASK)
 
#define AIPS_PACRB_SP5_MASK   (0x400U)
 
#define AIPS_PACRB_SP5_SHIFT   (10U)
 
#define AIPS_PACRB_SP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRB_SP5_SHIFT)) & AIPS_PACRB_SP5_MASK)
 
#define AIPS_PACRB_TP4_MASK   (0x1000U)
 
#define AIPS_PACRB_TP4_SHIFT   (12U)
 
#define AIPS_PACRB_TP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRB_TP4_SHIFT)) & AIPS_PACRB_TP4_MASK)
 
#define AIPS_PACRB_WP4_MASK   (0x2000U)
 
#define AIPS_PACRB_WP4_SHIFT   (13U)
 
#define AIPS_PACRB_WP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRB_WP4_SHIFT)) & AIPS_PACRB_WP4_MASK)
 
#define AIPS_PACRB_SP4_MASK   (0x4000U)
 
#define AIPS_PACRB_SP4_SHIFT   (14U)
 
#define AIPS_PACRB_SP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRB_SP4_SHIFT)) & AIPS_PACRB_SP4_MASK)
 
#define AIPS_PACRB_TP3_MASK   (0x10000U)
 
#define AIPS_PACRB_TP3_SHIFT   (16U)
 
#define AIPS_PACRB_TP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRB_TP3_SHIFT)) & AIPS_PACRB_TP3_MASK)
 
#define AIPS_PACRB_WP3_MASK   (0x20000U)
 
#define AIPS_PACRB_WP3_SHIFT   (17U)
 
#define AIPS_PACRB_WP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRB_WP3_SHIFT)) & AIPS_PACRB_WP3_MASK)
 
#define AIPS_PACRB_SP3_MASK   (0x40000U)
 
#define AIPS_PACRB_SP3_SHIFT   (18U)
 
#define AIPS_PACRB_SP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRB_SP3_SHIFT)) & AIPS_PACRB_SP3_MASK)
 
#define AIPS_PACRB_TP2_MASK   (0x100000U)
 
#define AIPS_PACRB_TP2_SHIFT   (20U)
 
#define AIPS_PACRB_TP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRB_TP2_SHIFT)) & AIPS_PACRB_TP2_MASK)
 
#define AIPS_PACRB_WP2_MASK   (0x200000U)
 
#define AIPS_PACRB_WP2_SHIFT   (21U)
 
#define AIPS_PACRB_WP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRB_WP2_SHIFT)) & AIPS_PACRB_WP2_MASK)
 
#define AIPS_PACRB_SP2_MASK   (0x400000U)
 
#define AIPS_PACRB_SP2_SHIFT   (22U)
 
#define AIPS_PACRB_SP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRB_SP2_SHIFT)) & AIPS_PACRB_SP2_MASK)
 
#define AIPS_PACRB_TP1_MASK   (0x1000000U)
 
#define AIPS_PACRB_TP1_SHIFT   (24U)
 
#define AIPS_PACRB_TP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRB_TP1_SHIFT)) & AIPS_PACRB_TP1_MASK)
 
#define AIPS_PACRB_WP1_MASK   (0x2000000U)
 
#define AIPS_PACRB_WP1_SHIFT   (25U)
 
#define AIPS_PACRB_WP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRB_WP1_SHIFT)) & AIPS_PACRB_WP1_MASK)
 
#define AIPS_PACRB_SP1_MASK   (0x4000000U)
 
#define AIPS_PACRB_SP1_SHIFT   (26U)
 
#define AIPS_PACRB_SP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRB_SP1_SHIFT)) & AIPS_PACRB_SP1_MASK)
 
#define AIPS_PACRB_TP0_MASK   (0x10000000U)
 
#define AIPS_PACRB_TP0_SHIFT   (28U)
 
#define AIPS_PACRB_TP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRB_TP0_SHIFT)) & AIPS_PACRB_TP0_MASK)
 
#define AIPS_PACRB_WP0_MASK   (0x20000000U)
 
#define AIPS_PACRB_WP0_SHIFT   (29U)
 
#define AIPS_PACRB_WP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRB_WP0_SHIFT)) & AIPS_PACRB_WP0_MASK)
 
#define AIPS_PACRB_SP0_MASK   (0x40000000U)
 
#define AIPS_PACRB_SP0_SHIFT   (30U)
 
#define AIPS_PACRB_SP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRB_SP0_SHIFT)) & AIPS_PACRB_SP0_MASK)
 
PACRC - Peripheral Access Control Register
#define AIPS_PACRC_TP7_MASK   (0x1U)
 
#define AIPS_PACRC_TP7_SHIFT   (0U)
 
#define AIPS_PACRC_TP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRC_TP7_SHIFT)) & AIPS_PACRC_TP7_MASK)
 
#define AIPS_PACRC_WP7_MASK   (0x2U)
 
#define AIPS_PACRC_WP7_SHIFT   (1U)
 
#define AIPS_PACRC_WP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRC_WP7_SHIFT)) & AIPS_PACRC_WP7_MASK)
 
#define AIPS_PACRC_SP7_MASK   (0x4U)
 
#define AIPS_PACRC_SP7_SHIFT   (2U)
 
#define AIPS_PACRC_SP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRC_SP7_SHIFT)) & AIPS_PACRC_SP7_MASK)
 
#define AIPS_PACRC_TP6_MASK   (0x10U)
 
#define AIPS_PACRC_TP6_SHIFT   (4U)
 
#define AIPS_PACRC_TP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRC_TP6_SHIFT)) & AIPS_PACRC_TP6_MASK)
 
#define AIPS_PACRC_WP6_MASK   (0x20U)
 
#define AIPS_PACRC_WP6_SHIFT   (5U)
 
#define AIPS_PACRC_WP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRC_WP6_SHIFT)) & AIPS_PACRC_WP6_MASK)
 
#define AIPS_PACRC_SP6_MASK   (0x40U)
 
#define AIPS_PACRC_SP6_SHIFT   (6U)
 
#define AIPS_PACRC_SP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRC_SP6_SHIFT)) & AIPS_PACRC_SP6_MASK)
 
#define AIPS_PACRC_TP5_MASK   (0x100U)
 
#define AIPS_PACRC_TP5_SHIFT   (8U)
 
#define AIPS_PACRC_TP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRC_TP5_SHIFT)) & AIPS_PACRC_TP5_MASK)
 
#define AIPS_PACRC_WP5_MASK   (0x200U)
 
#define AIPS_PACRC_WP5_SHIFT   (9U)
 
#define AIPS_PACRC_WP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRC_WP5_SHIFT)) & AIPS_PACRC_WP5_MASK)
 
#define AIPS_PACRC_SP5_MASK   (0x400U)
 
#define AIPS_PACRC_SP5_SHIFT   (10U)
 
#define AIPS_PACRC_SP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRC_SP5_SHIFT)) & AIPS_PACRC_SP5_MASK)
 
#define AIPS_PACRC_TP4_MASK   (0x1000U)
 
#define AIPS_PACRC_TP4_SHIFT   (12U)
 
#define AIPS_PACRC_TP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRC_TP4_SHIFT)) & AIPS_PACRC_TP4_MASK)
 
#define AIPS_PACRC_WP4_MASK   (0x2000U)
 
#define AIPS_PACRC_WP4_SHIFT   (13U)
 
#define AIPS_PACRC_WP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRC_WP4_SHIFT)) & AIPS_PACRC_WP4_MASK)
 
#define AIPS_PACRC_SP4_MASK   (0x4000U)
 
#define AIPS_PACRC_SP4_SHIFT   (14U)
 
#define AIPS_PACRC_SP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRC_SP4_SHIFT)) & AIPS_PACRC_SP4_MASK)
 
#define AIPS_PACRC_TP3_MASK   (0x10000U)
 
#define AIPS_PACRC_TP3_SHIFT   (16U)
 
#define AIPS_PACRC_TP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRC_TP3_SHIFT)) & AIPS_PACRC_TP3_MASK)
 
#define AIPS_PACRC_WP3_MASK   (0x20000U)
 
#define AIPS_PACRC_WP3_SHIFT   (17U)
 
#define AIPS_PACRC_WP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRC_WP3_SHIFT)) & AIPS_PACRC_WP3_MASK)
 
#define AIPS_PACRC_SP3_MASK   (0x40000U)
 
#define AIPS_PACRC_SP3_SHIFT   (18U)
 
#define AIPS_PACRC_SP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRC_SP3_SHIFT)) & AIPS_PACRC_SP3_MASK)
 
#define AIPS_PACRC_TP2_MASK   (0x100000U)
 
#define AIPS_PACRC_TP2_SHIFT   (20U)
 
#define AIPS_PACRC_TP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRC_TP2_SHIFT)) & AIPS_PACRC_TP2_MASK)
 
#define AIPS_PACRC_WP2_MASK   (0x200000U)
 
#define AIPS_PACRC_WP2_SHIFT   (21U)
 
#define AIPS_PACRC_WP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRC_WP2_SHIFT)) & AIPS_PACRC_WP2_MASK)
 
#define AIPS_PACRC_SP2_MASK   (0x400000U)
 
#define AIPS_PACRC_SP2_SHIFT   (22U)
 
#define AIPS_PACRC_SP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRC_SP2_SHIFT)) & AIPS_PACRC_SP2_MASK)
 
#define AIPS_PACRC_TP1_MASK   (0x1000000U)
 
#define AIPS_PACRC_TP1_SHIFT   (24U)
 
#define AIPS_PACRC_TP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRC_TP1_SHIFT)) & AIPS_PACRC_TP1_MASK)
 
#define AIPS_PACRC_WP1_MASK   (0x2000000U)
 
#define AIPS_PACRC_WP1_SHIFT   (25U)
 
#define AIPS_PACRC_WP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRC_WP1_SHIFT)) & AIPS_PACRC_WP1_MASK)
 
#define AIPS_PACRC_SP1_MASK   (0x4000000U)
 
#define AIPS_PACRC_SP1_SHIFT   (26U)
 
#define AIPS_PACRC_SP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRC_SP1_SHIFT)) & AIPS_PACRC_SP1_MASK)
 
#define AIPS_PACRC_TP0_MASK   (0x10000000U)
 
#define AIPS_PACRC_TP0_SHIFT   (28U)
 
#define AIPS_PACRC_TP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRC_TP0_SHIFT)) & AIPS_PACRC_TP0_MASK)
 
#define AIPS_PACRC_WP0_MASK   (0x20000000U)
 
#define AIPS_PACRC_WP0_SHIFT   (29U)
 
#define AIPS_PACRC_WP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRC_WP0_SHIFT)) & AIPS_PACRC_WP0_MASK)
 
#define AIPS_PACRC_SP0_MASK   (0x40000000U)
 
#define AIPS_PACRC_SP0_SHIFT   (30U)
 
#define AIPS_PACRC_SP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRC_SP0_SHIFT)) & AIPS_PACRC_SP0_MASK)
 
PACRD - Peripheral Access Control Register
#define AIPS_PACRD_TP7_MASK   (0x1U)
 
#define AIPS_PACRD_TP7_SHIFT   (0U)
 
#define AIPS_PACRD_TP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRD_TP7_SHIFT)) & AIPS_PACRD_TP7_MASK)
 
#define AIPS_PACRD_WP7_MASK   (0x2U)
 
#define AIPS_PACRD_WP7_SHIFT   (1U)
 
#define AIPS_PACRD_WP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRD_WP7_SHIFT)) & AIPS_PACRD_WP7_MASK)
 
#define AIPS_PACRD_SP7_MASK   (0x4U)
 
#define AIPS_PACRD_SP7_SHIFT   (2U)
 
#define AIPS_PACRD_SP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRD_SP7_SHIFT)) & AIPS_PACRD_SP7_MASK)
 
#define AIPS_PACRD_TP6_MASK   (0x10U)
 
#define AIPS_PACRD_TP6_SHIFT   (4U)
 
#define AIPS_PACRD_TP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRD_TP6_SHIFT)) & AIPS_PACRD_TP6_MASK)
 
#define AIPS_PACRD_WP6_MASK   (0x20U)
 
#define AIPS_PACRD_WP6_SHIFT   (5U)
 
#define AIPS_PACRD_WP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRD_WP6_SHIFT)) & AIPS_PACRD_WP6_MASK)
 
#define AIPS_PACRD_SP6_MASK   (0x40U)
 
#define AIPS_PACRD_SP6_SHIFT   (6U)
 
#define AIPS_PACRD_SP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRD_SP6_SHIFT)) & AIPS_PACRD_SP6_MASK)
 
#define AIPS_PACRD_TP5_MASK   (0x100U)
 
#define AIPS_PACRD_TP5_SHIFT   (8U)
 
#define AIPS_PACRD_TP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRD_TP5_SHIFT)) & AIPS_PACRD_TP5_MASK)
 
#define AIPS_PACRD_WP5_MASK   (0x200U)
 
#define AIPS_PACRD_WP5_SHIFT   (9U)
 
#define AIPS_PACRD_WP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRD_WP5_SHIFT)) & AIPS_PACRD_WP5_MASK)
 
#define AIPS_PACRD_SP5_MASK   (0x400U)
 
#define AIPS_PACRD_SP5_SHIFT   (10U)
 
#define AIPS_PACRD_SP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRD_SP5_SHIFT)) & AIPS_PACRD_SP5_MASK)
 
#define AIPS_PACRD_TP4_MASK   (0x1000U)
 
#define AIPS_PACRD_TP4_SHIFT   (12U)
 
#define AIPS_PACRD_TP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRD_TP4_SHIFT)) & AIPS_PACRD_TP4_MASK)
 
#define AIPS_PACRD_WP4_MASK   (0x2000U)
 
#define AIPS_PACRD_WP4_SHIFT   (13U)
 
#define AIPS_PACRD_WP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRD_WP4_SHIFT)) & AIPS_PACRD_WP4_MASK)
 
#define AIPS_PACRD_SP4_MASK   (0x4000U)
 
#define AIPS_PACRD_SP4_SHIFT   (14U)
 
#define AIPS_PACRD_SP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRD_SP4_SHIFT)) & AIPS_PACRD_SP4_MASK)
 
#define AIPS_PACRD_TP3_MASK   (0x10000U)
 
#define AIPS_PACRD_TP3_SHIFT   (16U)
 
#define AIPS_PACRD_TP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRD_TP3_SHIFT)) & AIPS_PACRD_TP3_MASK)
 
#define AIPS_PACRD_WP3_MASK   (0x20000U)
 
#define AIPS_PACRD_WP3_SHIFT   (17U)
 
#define AIPS_PACRD_WP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRD_WP3_SHIFT)) & AIPS_PACRD_WP3_MASK)
 
#define AIPS_PACRD_SP3_MASK   (0x40000U)
 
#define AIPS_PACRD_SP3_SHIFT   (18U)
 
#define AIPS_PACRD_SP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRD_SP3_SHIFT)) & AIPS_PACRD_SP3_MASK)
 
#define AIPS_PACRD_TP2_MASK   (0x100000U)
 
#define AIPS_PACRD_TP2_SHIFT   (20U)
 
#define AIPS_PACRD_TP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRD_TP2_SHIFT)) & AIPS_PACRD_TP2_MASK)
 
#define AIPS_PACRD_WP2_MASK   (0x200000U)
 
#define AIPS_PACRD_WP2_SHIFT   (21U)
 
#define AIPS_PACRD_WP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRD_WP2_SHIFT)) & AIPS_PACRD_WP2_MASK)
 
#define AIPS_PACRD_SP2_MASK   (0x400000U)
 
#define AIPS_PACRD_SP2_SHIFT   (22U)
 
#define AIPS_PACRD_SP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRD_SP2_SHIFT)) & AIPS_PACRD_SP2_MASK)
 
#define AIPS_PACRD_TP1_MASK   (0x1000000U)
 
#define AIPS_PACRD_TP1_SHIFT   (24U)
 
#define AIPS_PACRD_TP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRD_TP1_SHIFT)) & AIPS_PACRD_TP1_MASK)
 
#define AIPS_PACRD_WP1_MASK   (0x2000000U)
 
#define AIPS_PACRD_WP1_SHIFT   (25U)
 
#define AIPS_PACRD_WP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRD_WP1_SHIFT)) & AIPS_PACRD_WP1_MASK)
 
#define AIPS_PACRD_SP1_MASK   (0x4000000U)
 
#define AIPS_PACRD_SP1_SHIFT   (26U)
 
#define AIPS_PACRD_SP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRD_SP1_SHIFT)) & AIPS_PACRD_SP1_MASK)
 
#define AIPS_PACRD_TP0_MASK   (0x10000000U)
 
#define AIPS_PACRD_TP0_SHIFT   (28U)
 
#define AIPS_PACRD_TP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRD_TP0_SHIFT)) & AIPS_PACRD_TP0_MASK)
 
#define AIPS_PACRD_WP0_MASK   (0x20000000U)
 
#define AIPS_PACRD_WP0_SHIFT   (29U)
 
#define AIPS_PACRD_WP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRD_WP0_SHIFT)) & AIPS_PACRD_WP0_MASK)
 
#define AIPS_PACRD_SP0_MASK   (0x40000000U)
 
#define AIPS_PACRD_SP0_SHIFT   (30U)
 
#define AIPS_PACRD_SP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRD_SP0_SHIFT)) & AIPS_PACRD_SP0_MASK)
 
PACRE - Peripheral Access Control Register
#define AIPS_PACRE_TP7_MASK   (0x1U)
 
#define AIPS_PACRE_TP7_SHIFT   (0U)
 
#define AIPS_PACRE_TP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRE_TP7_SHIFT)) & AIPS_PACRE_TP7_MASK)
 
#define AIPS_PACRE_WP7_MASK   (0x2U)
 
#define AIPS_PACRE_WP7_SHIFT   (1U)
 
#define AIPS_PACRE_WP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRE_WP7_SHIFT)) & AIPS_PACRE_WP7_MASK)
 
#define AIPS_PACRE_SP7_MASK   (0x4U)
 
#define AIPS_PACRE_SP7_SHIFT   (2U)
 
#define AIPS_PACRE_SP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRE_SP7_SHIFT)) & AIPS_PACRE_SP7_MASK)
 
#define AIPS_PACRE_TP6_MASK   (0x10U)
 
#define AIPS_PACRE_TP6_SHIFT   (4U)
 
#define AIPS_PACRE_TP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRE_TP6_SHIFT)) & AIPS_PACRE_TP6_MASK)
 
#define AIPS_PACRE_WP6_MASK   (0x20U)
 
#define AIPS_PACRE_WP6_SHIFT   (5U)
 
#define AIPS_PACRE_WP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRE_WP6_SHIFT)) & AIPS_PACRE_WP6_MASK)
 
#define AIPS_PACRE_SP6_MASK   (0x40U)
 
#define AIPS_PACRE_SP6_SHIFT   (6U)
 
#define AIPS_PACRE_SP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRE_SP6_SHIFT)) & AIPS_PACRE_SP6_MASK)
 
#define AIPS_PACRE_TP5_MASK   (0x100U)
 
#define AIPS_PACRE_TP5_SHIFT   (8U)
 
#define AIPS_PACRE_TP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRE_TP5_SHIFT)) & AIPS_PACRE_TP5_MASK)
 
#define AIPS_PACRE_WP5_MASK   (0x200U)
 
#define AIPS_PACRE_WP5_SHIFT   (9U)
 
#define AIPS_PACRE_WP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRE_WP5_SHIFT)) & AIPS_PACRE_WP5_MASK)
 
#define AIPS_PACRE_SP5_MASK   (0x400U)
 
#define AIPS_PACRE_SP5_SHIFT   (10U)
 
#define AIPS_PACRE_SP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRE_SP5_SHIFT)) & AIPS_PACRE_SP5_MASK)
 
#define AIPS_PACRE_TP4_MASK   (0x1000U)
 
#define AIPS_PACRE_TP4_SHIFT   (12U)
 
#define AIPS_PACRE_TP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRE_TP4_SHIFT)) & AIPS_PACRE_TP4_MASK)
 
#define AIPS_PACRE_WP4_MASK   (0x2000U)
 
#define AIPS_PACRE_WP4_SHIFT   (13U)
 
#define AIPS_PACRE_WP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRE_WP4_SHIFT)) & AIPS_PACRE_WP4_MASK)
 
#define AIPS_PACRE_SP4_MASK   (0x4000U)
 
#define AIPS_PACRE_SP4_SHIFT   (14U)
 
#define AIPS_PACRE_SP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRE_SP4_SHIFT)) & AIPS_PACRE_SP4_MASK)
 
#define AIPS_PACRE_TP3_MASK   (0x10000U)
 
#define AIPS_PACRE_TP3_SHIFT   (16U)
 
#define AIPS_PACRE_TP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRE_TP3_SHIFT)) & AIPS_PACRE_TP3_MASK)
 
#define AIPS_PACRE_WP3_MASK   (0x20000U)
 
#define AIPS_PACRE_WP3_SHIFT   (17U)
 
#define AIPS_PACRE_WP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRE_WP3_SHIFT)) & AIPS_PACRE_WP3_MASK)
 
#define AIPS_PACRE_SP3_MASK   (0x40000U)
 
#define AIPS_PACRE_SP3_SHIFT   (18U)
 
#define AIPS_PACRE_SP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRE_SP3_SHIFT)) & AIPS_PACRE_SP3_MASK)
 
#define AIPS_PACRE_TP2_MASK   (0x100000U)
 
#define AIPS_PACRE_TP2_SHIFT   (20U)
 
#define AIPS_PACRE_TP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRE_TP2_SHIFT)) & AIPS_PACRE_TP2_MASK)
 
#define AIPS_PACRE_WP2_MASK   (0x200000U)
 
#define AIPS_PACRE_WP2_SHIFT   (21U)
 
#define AIPS_PACRE_WP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRE_WP2_SHIFT)) & AIPS_PACRE_WP2_MASK)
 
#define AIPS_PACRE_SP2_MASK   (0x400000U)
 
#define AIPS_PACRE_SP2_SHIFT   (22U)
 
#define AIPS_PACRE_SP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRE_SP2_SHIFT)) & AIPS_PACRE_SP2_MASK)
 
#define AIPS_PACRE_TP1_MASK   (0x1000000U)
 
#define AIPS_PACRE_TP1_SHIFT   (24U)
 
#define AIPS_PACRE_TP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRE_TP1_SHIFT)) & AIPS_PACRE_TP1_MASK)
 
#define AIPS_PACRE_WP1_MASK   (0x2000000U)
 
#define AIPS_PACRE_WP1_SHIFT   (25U)
 
#define AIPS_PACRE_WP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRE_WP1_SHIFT)) & AIPS_PACRE_WP1_MASK)
 
#define AIPS_PACRE_SP1_MASK   (0x4000000U)
 
#define AIPS_PACRE_SP1_SHIFT   (26U)
 
#define AIPS_PACRE_SP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRE_SP1_SHIFT)) & AIPS_PACRE_SP1_MASK)
 
#define AIPS_PACRE_TP0_MASK   (0x10000000U)
 
#define AIPS_PACRE_TP0_SHIFT   (28U)
 
#define AIPS_PACRE_TP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRE_TP0_SHIFT)) & AIPS_PACRE_TP0_MASK)
 
#define AIPS_PACRE_WP0_MASK   (0x20000000U)
 
#define AIPS_PACRE_WP0_SHIFT   (29U)
 
#define AIPS_PACRE_WP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRE_WP0_SHIFT)) & AIPS_PACRE_WP0_MASK)
 
#define AIPS_PACRE_SP0_MASK   (0x40000000U)
 
#define AIPS_PACRE_SP0_SHIFT   (30U)
 
#define AIPS_PACRE_SP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRE_SP0_SHIFT)) & AIPS_PACRE_SP0_MASK)
 
PACRF - Peripheral Access Control Register
#define AIPS_PACRF_TP7_MASK   (0x1U)
 
#define AIPS_PACRF_TP7_SHIFT   (0U)
 
#define AIPS_PACRF_TP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRF_TP7_SHIFT)) & AIPS_PACRF_TP7_MASK)
 
#define AIPS_PACRF_WP7_MASK   (0x2U)
 
#define AIPS_PACRF_WP7_SHIFT   (1U)
 
#define AIPS_PACRF_WP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRF_WP7_SHIFT)) & AIPS_PACRF_WP7_MASK)
 
#define AIPS_PACRF_SP7_MASK   (0x4U)
 
#define AIPS_PACRF_SP7_SHIFT   (2U)
 
#define AIPS_PACRF_SP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRF_SP7_SHIFT)) & AIPS_PACRF_SP7_MASK)
 
#define AIPS_PACRF_TP6_MASK   (0x10U)
 
#define AIPS_PACRF_TP6_SHIFT   (4U)
 
#define AIPS_PACRF_TP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRF_TP6_SHIFT)) & AIPS_PACRF_TP6_MASK)
 
#define AIPS_PACRF_WP6_MASK   (0x20U)
 
#define AIPS_PACRF_WP6_SHIFT   (5U)
 
#define AIPS_PACRF_WP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRF_WP6_SHIFT)) & AIPS_PACRF_WP6_MASK)
 
#define AIPS_PACRF_SP6_MASK   (0x40U)
 
#define AIPS_PACRF_SP6_SHIFT   (6U)
 
#define AIPS_PACRF_SP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRF_SP6_SHIFT)) & AIPS_PACRF_SP6_MASK)
 
#define AIPS_PACRF_TP5_MASK   (0x100U)
 
#define AIPS_PACRF_TP5_SHIFT   (8U)
 
#define AIPS_PACRF_TP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRF_TP5_SHIFT)) & AIPS_PACRF_TP5_MASK)
 
#define AIPS_PACRF_WP5_MASK   (0x200U)
 
#define AIPS_PACRF_WP5_SHIFT   (9U)
 
#define AIPS_PACRF_WP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRF_WP5_SHIFT)) & AIPS_PACRF_WP5_MASK)
 
#define AIPS_PACRF_SP5_MASK   (0x400U)
 
#define AIPS_PACRF_SP5_SHIFT   (10U)
 
#define AIPS_PACRF_SP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRF_SP5_SHIFT)) & AIPS_PACRF_SP5_MASK)
 
#define AIPS_PACRF_TP4_MASK   (0x1000U)
 
#define AIPS_PACRF_TP4_SHIFT   (12U)
 
#define AIPS_PACRF_TP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRF_TP4_SHIFT)) & AIPS_PACRF_TP4_MASK)
 
#define AIPS_PACRF_WP4_MASK   (0x2000U)
 
#define AIPS_PACRF_WP4_SHIFT   (13U)
 
#define AIPS_PACRF_WP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRF_WP4_SHIFT)) & AIPS_PACRF_WP4_MASK)
 
#define AIPS_PACRF_SP4_MASK   (0x4000U)
 
#define AIPS_PACRF_SP4_SHIFT   (14U)
 
#define AIPS_PACRF_SP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRF_SP4_SHIFT)) & AIPS_PACRF_SP4_MASK)
 
#define AIPS_PACRF_TP3_MASK   (0x10000U)
 
#define AIPS_PACRF_TP3_SHIFT   (16U)
 
#define AIPS_PACRF_TP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRF_TP3_SHIFT)) & AIPS_PACRF_TP3_MASK)
 
#define AIPS_PACRF_WP3_MASK   (0x20000U)
 
#define AIPS_PACRF_WP3_SHIFT   (17U)
 
#define AIPS_PACRF_WP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRF_WP3_SHIFT)) & AIPS_PACRF_WP3_MASK)
 
#define AIPS_PACRF_SP3_MASK   (0x40000U)
 
#define AIPS_PACRF_SP3_SHIFT   (18U)
 
#define AIPS_PACRF_SP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRF_SP3_SHIFT)) & AIPS_PACRF_SP3_MASK)
 
#define AIPS_PACRF_TP2_MASK   (0x100000U)
 
#define AIPS_PACRF_TP2_SHIFT   (20U)
 
#define AIPS_PACRF_TP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRF_TP2_SHIFT)) & AIPS_PACRF_TP2_MASK)
 
#define AIPS_PACRF_WP2_MASK   (0x200000U)
 
#define AIPS_PACRF_WP2_SHIFT   (21U)
 
#define AIPS_PACRF_WP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRF_WP2_SHIFT)) & AIPS_PACRF_WP2_MASK)
 
#define AIPS_PACRF_SP2_MASK   (0x400000U)
 
#define AIPS_PACRF_SP2_SHIFT   (22U)
 
#define AIPS_PACRF_SP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRF_SP2_SHIFT)) & AIPS_PACRF_SP2_MASK)
 
#define AIPS_PACRF_TP1_MASK   (0x1000000U)
 
#define AIPS_PACRF_TP1_SHIFT   (24U)
 
#define AIPS_PACRF_TP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRF_TP1_SHIFT)) & AIPS_PACRF_TP1_MASK)
 
#define AIPS_PACRF_WP1_MASK   (0x2000000U)
 
#define AIPS_PACRF_WP1_SHIFT   (25U)
 
#define AIPS_PACRF_WP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRF_WP1_SHIFT)) & AIPS_PACRF_WP1_MASK)
 
#define AIPS_PACRF_SP1_MASK   (0x4000000U)
 
#define AIPS_PACRF_SP1_SHIFT   (26U)
 
#define AIPS_PACRF_SP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRF_SP1_SHIFT)) & AIPS_PACRF_SP1_MASK)
 
#define AIPS_PACRF_TP0_MASK   (0x10000000U)
 
#define AIPS_PACRF_TP0_SHIFT   (28U)
 
#define AIPS_PACRF_TP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRF_TP0_SHIFT)) & AIPS_PACRF_TP0_MASK)
 
#define AIPS_PACRF_WP0_MASK   (0x20000000U)
 
#define AIPS_PACRF_WP0_SHIFT   (29U)
 
#define AIPS_PACRF_WP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRF_WP0_SHIFT)) & AIPS_PACRF_WP0_MASK)
 
#define AIPS_PACRF_SP0_MASK   (0x40000000U)
 
#define AIPS_PACRF_SP0_SHIFT   (30U)
 
#define AIPS_PACRF_SP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRF_SP0_SHIFT)) & AIPS_PACRF_SP0_MASK)
 
PACRG - Peripheral Access Control Register
#define AIPS_PACRG_TP7_MASK   (0x1U)
 
#define AIPS_PACRG_TP7_SHIFT   (0U)
 
#define AIPS_PACRG_TP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRG_TP7_SHIFT)) & AIPS_PACRG_TP7_MASK)
 
#define AIPS_PACRG_WP7_MASK   (0x2U)
 
#define AIPS_PACRG_WP7_SHIFT   (1U)
 
#define AIPS_PACRG_WP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRG_WP7_SHIFT)) & AIPS_PACRG_WP7_MASK)
 
#define AIPS_PACRG_SP7_MASK   (0x4U)
 
#define AIPS_PACRG_SP7_SHIFT   (2U)
 
#define AIPS_PACRG_SP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRG_SP7_SHIFT)) & AIPS_PACRG_SP7_MASK)
 
#define AIPS_PACRG_TP6_MASK   (0x10U)
 
#define AIPS_PACRG_TP6_SHIFT   (4U)
 
#define AIPS_PACRG_TP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRG_TP6_SHIFT)) & AIPS_PACRG_TP6_MASK)
 
#define AIPS_PACRG_WP6_MASK   (0x20U)
 
#define AIPS_PACRG_WP6_SHIFT   (5U)
 
#define AIPS_PACRG_WP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRG_WP6_SHIFT)) & AIPS_PACRG_WP6_MASK)
 
#define AIPS_PACRG_SP6_MASK   (0x40U)
 
#define AIPS_PACRG_SP6_SHIFT   (6U)
 
#define AIPS_PACRG_SP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRG_SP6_SHIFT)) & AIPS_PACRG_SP6_MASK)
 
#define AIPS_PACRG_TP5_MASK   (0x100U)
 
#define AIPS_PACRG_TP5_SHIFT   (8U)
 
#define AIPS_PACRG_TP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRG_TP5_SHIFT)) & AIPS_PACRG_TP5_MASK)
 
#define AIPS_PACRG_WP5_MASK   (0x200U)
 
#define AIPS_PACRG_WP5_SHIFT   (9U)
 
#define AIPS_PACRG_WP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRG_WP5_SHIFT)) & AIPS_PACRG_WP5_MASK)
 
#define AIPS_PACRG_SP5_MASK   (0x400U)
 
#define AIPS_PACRG_SP5_SHIFT   (10U)
 
#define AIPS_PACRG_SP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRG_SP5_SHIFT)) & AIPS_PACRG_SP5_MASK)
 
#define AIPS_PACRG_TP4_MASK   (0x1000U)
 
#define AIPS_PACRG_TP4_SHIFT   (12U)
 
#define AIPS_PACRG_TP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRG_TP4_SHIFT)) & AIPS_PACRG_TP4_MASK)
 
#define AIPS_PACRG_WP4_MASK   (0x2000U)
 
#define AIPS_PACRG_WP4_SHIFT   (13U)
 
#define AIPS_PACRG_WP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRG_WP4_SHIFT)) & AIPS_PACRG_WP4_MASK)
 
#define AIPS_PACRG_SP4_MASK   (0x4000U)
 
#define AIPS_PACRG_SP4_SHIFT   (14U)
 
#define AIPS_PACRG_SP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRG_SP4_SHIFT)) & AIPS_PACRG_SP4_MASK)
 
#define AIPS_PACRG_TP3_MASK   (0x10000U)
 
#define AIPS_PACRG_TP3_SHIFT   (16U)
 
#define AIPS_PACRG_TP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRG_TP3_SHIFT)) & AIPS_PACRG_TP3_MASK)
 
#define AIPS_PACRG_WP3_MASK   (0x20000U)
 
#define AIPS_PACRG_WP3_SHIFT   (17U)
 
#define AIPS_PACRG_WP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRG_WP3_SHIFT)) & AIPS_PACRG_WP3_MASK)
 
#define AIPS_PACRG_SP3_MASK   (0x40000U)
 
#define AIPS_PACRG_SP3_SHIFT   (18U)
 
#define AIPS_PACRG_SP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRG_SP3_SHIFT)) & AIPS_PACRG_SP3_MASK)
 
#define AIPS_PACRG_TP2_MASK   (0x100000U)
 
#define AIPS_PACRG_TP2_SHIFT   (20U)
 
#define AIPS_PACRG_TP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRG_TP2_SHIFT)) & AIPS_PACRG_TP2_MASK)
 
#define AIPS_PACRG_WP2_MASK   (0x200000U)
 
#define AIPS_PACRG_WP2_SHIFT   (21U)
 
#define AIPS_PACRG_WP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRG_WP2_SHIFT)) & AIPS_PACRG_WP2_MASK)
 
#define AIPS_PACRG_SP2_MASK   (0x400000U)
 
#define AIPS_PACRG_SP2_SHIFT   (22U)
 
#define AIPS_PACRG_SP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRG_SP2_SHIFT)) & AIPS_PACRG_SP2_MASK)
 
#define AIPS_PACRG_TP1_MASK   (0x1000000U)
 
#define AIPS_PACRG_TP1_SHIFT   (24U)
 
#define AIPS_PACRG_TP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRG_TP1_SHIFT)) & AIPS_PACRG_TP1_MASK)
 
#define AIPS_PACRG_WP1_MASK   (0x2000000U)
 
#define AIPS_PACRG_WP1_SHIFT   (25U)
 
#define AIPS_PACRG_WP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRG_WP1_SHIFT)) & AIPS_PACRG_WP1_MASK)
 
#define AIPS_PACRG_SP1_MASK   (0x4000000U)
 
#define AIPS_PACRG_SP1_SHIFT   (26U)
 
#define AIPS_PACRG_SP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRG_SP1_SHIFT)) & AIPS_PACRG_SP1_MASK)
 
#define AIPS_PACRG_TP0_MASK   (0x10000000U)
 
#define AIPS_PACRG_TP0_SHIFT   (28U)
 
#define AIPS_PACRG_TP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRG_TP0_SHIFT)) & AIPS_PACRG_TP0_MASK)
 
#define AIPS_PACRG_WP0_MASK   (0x20000000U)
 
#define AIPS_PACRG_WP0_SHIFT   (29U)
 
#define AIPS_PACRG_WP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRG_WP0_SHIFT)) & AIPS_PACRG_WP0_MASK)
 
#define AIPS_PACRG_SP0_MASK   (0x40000000U)
 
#define AIPS_PACRG_SP0_SHIFT   (30U)
 
#define AIPS_PACRG_SP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRG_SP0_SHIFT)) & AIPS_PACRG_SP0_MASK)
 
PACRH - Peripheral Access Control Register
#define AIPS_PACRH_TP7_MASK   (0x1U)
 
#define AIPS_PACRH_TP7_SHIFT   (0U)
 
#define AIPS_PACRH_TP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRH_TP7_SHIFT)) & AIPS_PACRH_TP7_MASK)
 
#define AIPS_PACRH_WP7_MASK   (0x2U)
 
#define AIPS_PACRH_WP7_SHIFT   (1U)
 
#define AIPS_PACRH_WP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRH_WP7_SHIFT)) & AIPS_PACRH_WP7_MASK)
 
#define AIPS_PACRH_SP7_MASK   (0x4U)
 
#define AIPS_PACRH_SP7_SHIFT   (2U)
 
#define AIPS_PACRH_SP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRH_SP7_SHIFT)) & AIPS_PACRH_SP7_MASK)
 
#define AIPS_PACRH_TP6_MASK   (0x10U)
 
#define AIPS_PACRH_TP6_SHIFT   (4U)
 
#define AIPS_PACRH_TP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRH_TP6_SHIFT)) & AIPS_PACRH_TP6_MASK)
 
#define AIPS_PACRH_WP6_MASK   (0x20U)
 
#define AIPS_PACRH_WP6_SHIFT   (5U)
 
#define AIPS_PACRH_WP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRH_WP6_SHIFT)) & AIPS_PACRH_WP6_MASK)
 
#define AIPS_PACRH_SP6_MASK   (0x40U)
 
#define AIPS_PACRH_SP6_SHIFT   (6U)
 
#define AIPS_PACRH_SP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRH_SP6_SHIFT)) & AIPS_PACRH_SP6_MASK)
 
#define AIPS_PACRH_TP5_MASK   (0x100U)
 
#define AIPS_PACRH_TP5_SHIFT   (8U)
 
#define AIPS_PACRH_TP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRH_TP5_SHIFT)) & AIPS_PACRH_TP5_MASK)
 
#define AIPS_PACRH_WP5_MASK   (0x200U)
 
#define AIPS_PACRH_WP5_SHIFT   (9U)
 
#define AIPS_PACRH_WP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRH_WP5_SHIFT)) & AIPS_PACRH_WP5_MASK)
 
#define AIPS_PACRH_SP5_MASK   (0x400U)
 
#define AIPS_PACRH_SP5_SHIFT   (10U)
 
#define AIPS_PACRH_SP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRH_SP5_SHIFT)) & AIPS_PACRH_SP5_MASK)
 
#define AIPS_PACRH_TP4_MASK   (0x1000U)
 
#define AIPS_PACRH_TP4_SHIFT   (12U)
 
#define AIPS_PACRH_TP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRH_TP4_SHIFT)) & AIPS_PACRH_TP4_MASK)
 
#define AIPS_PACRH_WP4_MASK   (0x2000U)
 
#define AIPS_PACRH_WP4_SHIFT   (13U)
 
#define AIPS_PACRH_WP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRH_WP4_SHIFT)) & AIPS_PACRH_WP4_MASK)
 
#define AIPS_PACRH_SP4_MASK   (0x4000U)
 
#define AIPS_PACRH_SP4_SHIFT   (14U)
 
#define AIPS_PACRH_SP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRH_SP4_SHIFT)) & AIPS_PACRH_SP4_MASK)
 
#define AIPS_PACRH_TP3_MASK   (0x10000U)
 
#define AIPS_PACRH_TP3_SHIFT   (16U)
 
#define AIPS_PACRH_TP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRH_TP3_SHIFT)) & AIPS_PACRH_TP3_MASK)
 
#define AIPS_PACRH_WP3_MASK   (0x20000U)
 
#define AIPS_PACRH_WP3_SHIFT   (17U)
 
#define AIPS_PACRH_WP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRH_WP3_SHIFT)) & AIPS_PACRH_WP3_MASK)
 
#define AIPS_PACRH_SP3_MASK   (0x40000U)
 
#define AIPS_PACRH_SP3_SHIFT   (18U)
 
#define AIPS_PACRH_SP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRH_SP3_SHIFT)) & AIPS_PACRH_SP3_MASK)
 
#define AIPS_PACRH_TP2_MASK   (0x100000U)
 
#define AIPS_PACRH_TP2_SHIFT   (20U)
 
#define AIPS_PACRH_TP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRH_TP2_SHIFT)) & AIPS_PACRH_TP2_MASK)
 
#define AIPS_PACRH_WP2_MASK   (0x200000U)
 
#define AIPS_PACRH_WP2_SHIFT   (21U)
 
#define AIPS_PACRH_WP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRH_WP2_SHIFT)) & AIPS_PACRH_WP2_MASK)
 
#define AIPS_PACRH_SP2_MASK   (0x400000U)
 
#define AIPS_PACRH_SP2_SHIFT   (22U)
 
#define AIPS_PACRH_SP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRH_SP2_SHIFT)) & AIPS_PACRH_SP2_MASK)
 
#define AIPS_PACRH_TP1_MASK   (0x1000000U)
 
#define AIPS_PACRH_TP1_SHIFT   (24U)
 
#define AIPS_PACRH_TP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRH_TP1_SHIFT)) & AIPS_PACRH_TP1_MASK)
 
#define AIPS_PACRH_WP1_MASK   (0x2000000U)
 
#define AIPS_PACRH_WP1_SHIFT   (25U)
 
#define AIPS_PACRH_WP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRH_WP1_SHIFT)) & AIPS_PACRH_WP1_MASK)
 
#define AIPS_PACRH_SP1_MASK   (0x4000000U)
 
#define AIPS_PACRH_SP1_SHIFT   (26U)
 
#define AIPS_PACRH_SP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRH_SP1_SHIFT)) & AIPS_PACRH_SP1_MASK)
 
#define AIPS_PACRH_TP0_MASK   (0x10000000U)
 
#define AIPS_PACRH_TP0_SHIFT   (28U)
 
#define AIPS_PACRH_TP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRH_TP0_SHIFT)) & AIPS_PACRH_TP0_MASK)
 
#define AIPS_PACRH_WP0_MASK   (0x20000000U)
 
#define AIPS_PACRH_WP0_SHIFT   (29U)
 
#define AIPS_PACRH_WP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRH_WP0_SHIFT)) & AIPS_PACRH_WP0_MASK)
 
#define AIPS_PACRH_SP0_MASK   (0x40000000U)
 
#define AIPS_PACRH_SP0_SHIFT   (30U)
 
#define AIPS_PACRH_SP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRH_SP0_SHIFT)) & AIPS_PACRH_SP0_MASK)
 
PACRI - Peripheral Access Control Register
#define AIPS_PACRI_TP7_MASK   (0x1U)
 
#define AIPS_PACRI_TP7_SHIFT   (0U)
 
#define AIPS_PACRI_TP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRI_TP7_SHIFT)) & AIPS_PACRI_TP7_MASK)
 
#define AIPS_PACRI_WP7_MASK   (0x2U)
 
#define AIPS_PACRI_WP7_SHIFT   (1U)
 
#define AIPS_PACRI_WP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRI_WP7_SHIFT)) & AIPS_PACRI_WP7_MASK)
 
#define AIPS_PACRI_SP7_MASK   (0x4U)
 
#define AIPS_PACRI_SP7_SHIFT   (2U)
 
#define AIPS_PACRI_SP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRI_SP7_SHIFT)) & AIPS_PACRI_SP7_MASK)
 
#define AIPS_PACRI_TP6_MASK   (0x10U)
 
#define AIPS_PACRI_TP6_SHIFT   (4U)
 
#define AIPS_PACRI_TP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRI_TP6_SHIFT)) & AIPS_PACRI_TP6_MASK)
 
#define AIPS_PACRI_WP6_MASK   (0x20U)
 
#define AIPS_PACRI_WP6_SHIFT   (5U)
 
#define AIPS_PACRI_WP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRI_WP6_SHIFT)) & AIPS_PACRI_WP6_MASK)
 
#define AIPS_PACRI_SP6_MASK   (0x40U)
 
#define AIPS_PACRI_SP6_SHIFT   (6U)
 
#define AIPS_PACRI_SP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRI_SP6_SHIFT)) & AIPS_PACRI_SP6_MASK)
 
#define AIPS_PACRI_TP5_MASK   (0x100U)
 
#define AIPS_PACRI_TP5_SHIFT   (8U)
 
#define AIPS_PACRI_TP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRI_TP5_SHIFT)) & AIPS_PACRI_TP5_MASK)
 
#define AIPS_PACRI_WP5_MASK   (0x200U)
 
#define AIPS_PACRI_WP5_SHIFT   (9U)
 
#define AIPS_PACRI_WP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRI_WP5_SHIFT)) & AIPS_PACRI_WP5_MASK)
 
#define AIPS_PACRI_SP5_MASK   (0x400U)
 
#define AIPS_PACRI_SP5_SHIFT   (10U)
 
#define AIPS_PACRI_SP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRI_SP5_SHIFT)) & AIPS_PACRI_SP5_MASK)
 
#define AIPS_PACRI_TP4_MASK   (0x1000U)
 
#define AIPS_PACRI_TP4_SHIFT   (12U)
 
#define AIPS_PACRI_TP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRI_TP4_SHIFT)) & AIPS_PACRI_TP4_MASK)
 
#define AIPS_PACRI_WP4_MASK   (0x2000U)
 
#define AIPS_PACRI_WP4_SHIFT   (13U)
 
#define AIPS_PACRI_WP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRI_WP4_SHIFT)) & AIPS_PACRI_WP4_MASK)
 
#define AIPS_PACRI_SP4_MASK   (0x4000U)
 
#define AIPS_PACRI_SP4_SHIFT   (14U)
 
#define AIPS_PACRI_SP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRI_SP4_SHIFT)) & AIPS_PACRI_SP4_MASK)
 
#define AIPS_PACRI_TP3_MASK   (0x10000U)
 
#define AIPS_PACRI_TP3_SHIFT   (16U)
 
#define AIPS_PACRI_TP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRI_TP3_SHIFT)) & AIPS_PACRI_TP3_MASK)
 
#define AIPS_PACRI_WP3_MASK   (0x20000U)
 
#define AIPS_PACRI_WP3_SHIFT   (17U)
 
#define AIPS_PACRI_WP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRI_WP3_SHIFT)) & AIPS_PACRI_WP3_MASK)
 
#define AIPS_PACRI_SP3_MASK   (0x40000U)
 
#define AIPS_PACRI_SP3_SHIFT   (18U)
 
#define AIPS_PACRI_SP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRI_SP3_SHIFT)) & AIPS_PACRI_SP3_MASK)
 
#define AIPS_PACRI_TP2_MASK   (0x100000U)
 
#define AIPS_PACRI_TP2_SHIFT   (20U)
 
#define AIPS_PACRI_TP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRI_TP2_SHIFT)) & AIPS_PACRI_TP2_MASK)
 
#define AIPS_PACRI_WP2_MASK   (0x200000U)
 
#define AIPS_PACRI_WP2_SHIFT   (21U)
 
#define AIPS_PACRI_WP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRI_WP2_SHIFT)) & AIPS_PACRI_WP2_MASK)
 
#define AIPS_PACRI_SP2_MASK   (0x400000U)
 
#define AIPS_PACRI_SP2_SHIFT   (22U)
 
#define AIPS_PACRI_SP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRI_SP2_SHIFT)) & AIPS_PACRI_SP2_MASK)
 
#define AIPS_PACRI_TP1_MASK   (0x1000000U)
 
#define AIPS_PACRI_TP1_SHIFT   (24U)
 
#define AIPS_PACRI_TP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRI_TP1_SHIFT)) & AIPS_PACRI_TP1_MASK)
 
#define AIPS_PACRI_WP1_MASK   (0x2000000U)
 
#define AIPS_PACRI_WP1_SHIFT   (25U)
 
#define AIPS_PACRI_WP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRI_WP1_SHIFT)) & AIPS_PACRI_WP1_MASK)
 
#define AIPS_PACRI_SP1_MASK   (0x4000000U)
 
#define AIPS_PACRI_SP1_SHIFT   (26U)
 
#define AIPS_PACRI_SP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRI_SP1_SHIFT)) & AIPS_PACRI_SP1_MASK)
 
#define AIPS_PACRI_TP0_MASK   (0x10000000U)
 
#define AIPS_PACRI_TP0_SHIFT   (28U)
 
#define AIPS_PACRI_TP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRI_TP0_SHIFT)) & AIPS_PACRI_TP0_MASK)
 
#define AIPS_PACRI_WP0_MASK   (0x20000000U)
 
#define AIPS_PACRI_WP0_SHIFT   (29U)
 
#define AIPS_PACRI_WP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRI_WP0_SHIFT)) & AIPS_PACRI_WP0_MASK)
 
#define AIPS_PACRI_SP0_MASK   (0x40000000U)
 
#define AIPS_PACRI_SP0_SHIFT   (30U)
 
#define AIPS_PACRI_SP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRI_SP0_SHIFT)) & AIPS_PACRI_SP0_MASK)
 
PACRJ - Peripheral Access Control Register
#define AIPS_PACRJ_TP7_MASK   (0x1U)
 
#define AIPS_PACRJ_TP7_SHIFT   (0U)
 
#define AIPS_PACRJ_TP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRJ_TP7_SHIFT)) & AIPS_PACRJ_TP7_MASK)
 
#define AIPS_PACRJ_WP7_MASK   (0x2U)
 
#define AIPS_PACRJ_WP7_SHIFT   (1U)
 
#define AIPS_PACRJ_WP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRJ_WP7_SHIFT)) & AIPS_PACRJ_WP7_MASK)
 
#define AIPS_PACRJ_SP7_MASK   (0x4U)
 
#define AIPS_PACRJ_SP7_SHIFT   (2U)
 
#define AIPS_PACRJ_SP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRJ_SP7_SHIFT)) & AIPS_PACRJ_SP7_MASK)
 
#define AIPS_PACRJ_TP6_MASK   (0x10U)
 
#define AIPS_PACRJ_TP6_SHIFT   (4U)
 
#define AIPS_PACRJ_TP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRJ_TP6_SHIFT)) & AIPS_PACRJ_TP6_MASK)
 
#define AIPS_PACRJ_WP6_MASK   (0x20U)
 
#define AIPS_PACRJ_WP6_SHIFT   (5U)
 
#define AIPS_PACRJ_WP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRJ_WP6_SHIFT)) & AIPS_PACRJ_WP6_MASK)
 
#define AIPS_PACRJ_SP6_MASK   (0x40U)
 
#define AIPS_PACRJ_SP6_SHIFT   (6U)
 
#define AIPS_PACRJ_SP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRJ_SP6_SHIFT)) & AIPS_PACRJ_SP6_MASK)
 
#define AIPS_PACRJ_TP5_MASK   (0x100U)
 
#define AIPS_PACRJ_TP5_SHIFT   (8U)
 
#define AIPS_PACRJ_TP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRJ_TP5_SHIFT)) & AIPS_PACRJ_TP5_MASK)
 
#define AIPS_PACRJ_WP5_MASK   (0x200U)
 
#define AIPS_PACRJ_WP5_SHIFT   (9U)
 
#define AIPS_PACRJ_WP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRJ_WP5_SHIFT)) & AIPS_PACRJ_WP5_MASK)
 
#define AIPS_PACRJ_SP5_MASK   (0x400U)
 
#define AIPS_PACRJ_SP5_SHIFT   (10U)
 
#define AIPS_PACRJ_SP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRJ_SP5_SHIFT)) & AIPS_PACRJ_SP5_MASK)
 
#define AIPS_PACRJ_TP4_MASK   (0x1000U)
 
#define AIPS_PACRJ_TP4_SHIFT   (12U)
 
#define AIPS_PACRJ_TP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRJ_TP4_SHIFT)) & AIPS_PACRJ_TP4_MASK)
 
#define AIPS_PACRJ_WP4_MASK   (0x2000U)
 
#define AIPS_PACRJ_WP4_SHIFT   (13U)
 
#define AIPS_PACRJ_WP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRJ_WP4_SHIFT)) & AIPS_PACRJ_WP4_MASK)
 
#define AIPS_PACRJ_SP4_MASK   (0x4000U)
 
#define AIPS_PACRJ_SP4_SHIFT   (14U)
 
#define AIPS_PACRJ_SP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRJ_SP4_SHIFT)) & AIPS_PACRJ_SP4_MASK)
 
#define AIPS_PACRJ_TP3_MASK   (0x10000U)
 
#define AIPS_PACRJ_TP3_SHIFT   (16U)
 
#define AIPS_PACRJ_TP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRJ_TP3_SHIFT)) & AIPS_PACRJ_TP3_MASK)
 
#define AIPS_PACRJ_WP3_MASK   (0x20000U)
 
#define AIPS_PACRJ_WP3_SHIFT   (17U)
 
#define AIPS_PACRJ_WP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRJ_WP3_SHIFT)) & AIPS_PACRJ_WP3_MASK)
 
#define AIPS_PACRJ_SP3_MASK   (0x40000U)
 
#define AIPS_PACRJ_SP3_SHIFT   (18U)
 
#define AIPS_PACRJ_SP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRJ_SP3_SHIFT)) & AIPS_PACRJ_SP3_MASK)
 
#define AIPS_PACRJ_TP2_MASK   (0x100000U)
 
#define AIPS_PACRJ_TP2_SHIFT   (20U)
 
#define AIPS_PACRJ_TP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRJ_TP2_SHIFT)) & AIPS_PACRJ_TP2_MASK)
 
#define AIPS_PACRJ_WP2_MASK   (0x200000U)
 
#define AIPS_PACRJ_WP2_SHIFT   (21U)
 
#define AIPS_PACRJ_WP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRJ_WP2_SHIFT)) & AIPS_PACRJ_WP2_MASK)
 
#define AIPS_PACRJ_SP2_MASK   (0x400000U)
 
#define AIPS_PACRJ_SP2_SHIFT   (22U)
 
#define AIPS_PACRJ_SP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRJ_SP2_SHIFT)) & AIPS_PACRJ_SP2_MASK)
 
#define AIPS_PACRJ_TP1_MASK   (0x1000000U)
 
#define AIPS_PACRJ_TP1_SHIFT   (24U)
 
#define AIPS_PACRJ_TP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRJ_TP1_SHIFT)) & AIPS_PACRJ_TP1_MASK)
 
#define AIPS_PACRJ_WP1_MASK   (0x2000000U)
 
#define AIPS_PACRJ_WP1_SHIFT   (25U)
 
#define AIPS_PACRJ_WP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRJ_WP1_SHIFT)) & AIPS_PACRJ_WP1_MASK)
 
#define AIPS_PACRJ_SP1_MASK   (0x4000000U)
 
#define AIPS_PACRJ_SP1_SHIFT   (26U)
 
#define AIPS_PACRJ_SP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRJ_SP1_SHIFT)) & AIPS_PACRJ_SP1_MASK)
 
#define AIPS_PACRJ_TP0_MASK   (0x10000000U)
 
#define AIPS_PACRJ_TP0_SHIFT   (28U)
 
#define AIPS_PACRJ_TP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRJ_TP0_SHIFT)) & AIPS_PACRJ_TP0_MASK)
 
#define AIPS_PACRJ_WP0_MASK   (0x20000000U)
 
#define AIPS_PACRJ_WP0_SHIFT   (29U)
 
#define AIPS_PACRJ_WP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRJ_WP0_SHIFT)) & AIPS_PACRJ_WP0_MASK)
 
#define AIPS_PACRJ_SP0_MASK   (0x40000000U)
 
#define AIPS_PACRJ_SP0_SHIFT   (30U)
 
#define AIPS_PACRJ_SP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRJ_SP0_SHIFT)) & AIPS_PACRJ_SP0_MASK)
 
PACRK - Peripheral Access Control Register
#define AIPS_PACRK_TP7_MASK   (0x1U)
 
#define AIPS_PACRK_TP7_SHIFT   (0U)
 
#define AIPS_PACRK_TP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRK_TP7_SHIFT)) & AIPS_PACRK_TP7_MASK)
 
#define AIPS_PACRK_WP7_MASK   (0x2U)
 
#define AIPS_PACRK_WP7_SHIFT   (1U)
 
#define AIPS_PACRK_WP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRK_WP7_SHIFT)) & AIPS_PACRK_WP7_MASK)
 
#define AIPS_PACRK_SP7_MASK   (0x4U)
 
#define AIPS_PACRK_SP7_SHIFT   (2U)
 
#define AIPS_PACRK_SP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRK_SP7_SHIFT)) & AIPS_PACRK_SP7_MASK)
 
#define AIPS_PACRK_TP6_MASK   (0x10U)
 
#define AIPS_PACRK_TP6_SHIFT   (4U)
 
#define AIPS_PACRK_TP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRK_TP6_SHIFT)) & AIPS_PACRK_TP6_MASK)
 
#define AIPS_PACRK_WP6_MASK   (0x20U)
 
#define AIPS_PACRK_WP6_SHIFT   (5U)
 
#define AIPS_PACRK_WP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRK_WP6_SHIFT)) & AIPS_PACRK_WP6_MASK)
 
#define AIPS_PACRK_SP6_MASK   (0x40U)
 
#define AIPS_PACRK_SP6_SHIFT   (6U)
 
#define AIPS_PACRK_SP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRK_SP6_SHIFT)) & AIPS_PACRK_SP6_MASK)
 
#define AIPS_PACRK_TP5_MASK   (0x100U)
 
#define AIPS_PACRK_TP5_SHIFT   (8U)
 
#define AIPS_PACRK_TP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRK_TP5_SHIFT)) & AIPS_PACRK_TP5_MASK)
 
#define AIPS_PACRK_WP5_MASK   (0x200U)
 
#define AIPS_PACRK_WP5_SHIFT   (9U)
 
#define AIPS_PACRK_WP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRK_WP5_SHIFT)) & AIPS_PACRK_WP5_MASK)
 
#define AIPS_PACRK_SP5_MASK   (0x400U)
 
#define AIPS_PACRK_SP5_SHIFT   (10U)
 
#define AIPS_PACRK_SP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRK_SP5_SHIFT)) & AIPS_PACRK_SP5_MASK)
 
#define AIPS_PACRK_TP4_MASK   (0x1000U)
 
#define AIPS_PACRK_TP4_SHIFT   (12U)
 
#define AIPS_PACRK_TP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRK_TP4_SHIFT)) & AIPS_PACRK_TP4_MASK)
 
#define AIPS_PACRK_WP4_MASK   (0x2000U)
 
#define AIPS_PACRK_WP4_SHIFT   (13U)
 
#define AIPS_PACRK_WP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRK_WP4_SHIFT)) & AIPS_PACRK_WP4_MASK)
 
#define AIPS_PACRK_SP4_MASK   (0x4000U)
 
#define AIPS_PACRK_SP4_SHIFT   (14U)
 
#define AIPS_PACRK_SP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRK_SP4_SHIFT)) & AIPS_PACRK_SP4_MASK)
 
#define AIPS_PACRK_TP3_MASK   (0x10000U)
 
#define AIPS_PACRK_TP3_SHIFT   (16U)
 
#define AIPS_PACRK_TP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRK_TP3_SHIFT)) & AIPS_PACRK_TP3_MASK)
 
#define AIPS_PACRK_WP3_MASK   (0x20000U)
 
#define AIPS_PACRK_WP3_SHIFT   (17U)
 
#define AIPS_PACRK_WP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRK_WP3_SHIFT)) & AIPS_PACRK_WP3_MASK)
 
#define AIPS_PACRK_SP3_MASK   (0x40000U)
 
#define AIPS_PACRK_SP3_SHIFT   (18U)
 
#define AIPS_PACRK_SP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRK_SP3_SHIFT)) & AIPS_PACRK_SP3_MASK)
 
#define AIPS_PACRK_TP2_MASK   (0x100000U)
 
#define AIPS_PACRK_TP2_SHIFT   (20U)
 
#define AIPS_PACRK_TP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRK_TP2_SHIFT)) & AIPS_PACRK_TP2_MASK)
 
#define AIPS_PACRK_WP2_MASK   (0x200000U)
 
#define AIPS_PACRK_WP2_SHIFT   (21U)
 
#define AIPS_PACRK_WP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRK_WP2_SHIFT)) & AIPS_PACRK_WP2_MASK)
 
#define AIPS_PACRK_SP2_MASK   (0x400000U)
 
#define AIPS_PACRK_SP2_SHIFT   (22U)
 
#define AIPS_PACRK_SP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRK_SP2_SHIFT)) & AIPS_PACRK_SP2_MASK)
 
#define AIPS_PACRK_TP1_MASK   (0x1000000U)
 
#define AIPS_PACRK_TP1_SHIFT   (24U)
 
#define AIPS_PACRK_TP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRK_TP1_SHIFT)) & AIPS_PACRK_TP1_MASK)
 
#define AIPS_PACRK_WP1_MASK   (0x2000000U)
 
#define AIPS_PACRK_WP1_SHIFT   (25U)
 
#define AIPS_PACRK_WP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRK_WP1_SHIFT)) & AIPS_PACRK_WP1_MASK)
 
#define AIPS_PACRK_SP1_MASK   (0x4000000U)
 
#define AIPS_PACRK_SP1_SHIFT   (26U)
 
#define AIPS_PACRK_SP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRK_SP1_SHIFT)) & AIPS_PACRK_SP1_MASK)
 
#define AIPS_PACRK_TP0_MASK   (0x10000000U)
 
#define AIPS_PACRK_TP0_SHIFT   (28U)
 
#define AIPS_PACRK_TP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRK_TP0_SHIFT)) & AIPS_PACRK_TP0_MASK)
 
#define AIPS_PACRK_WP0_MASK   (0x20000000U)
 
#define AIPS_PACRK_WP0_SHIFT   (29U)
 
#define AIPS_PACRK_WP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRK_WP0_SHIFT)) & AIPS_PACRK_WP0_MASK)
 
#define AIPS_PACRK_SP0_MASK   (0x40000000U)
 
#define AIPS_PACRK_SP0_SHIFT   (30U)
 
#define AIPS_PACRK_SP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRK_SP0_SHIFT)) & AIPS_PACRK_SP0_MASK)
 
PACRL - Peripheral Access Control Register
#define AIPS_PACRL_TP7_MASK   (0x1U)
 
#define AIPS_PACRL_TP7_SHIFT   (0U)
 
#define AIPS_PACRL_TP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRL_TP7_SHIFT)) & AIPS_PACRL_TP7_MASK)
 
#define AIPS_PACRL_WP7_MASK   (0x2U)
 
#define AIPS_PACRL_WP7_SHIFT   (1U)
 
#define AIPS_PACRL_WP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRL_WP7_SHIFT)) & AIPS_PACRL_WP7_MASK)
 
#define AIPS_PACRL_SP7_MASK   (0x4U)
 
#define AIPS_PACRL_SP7_SHIFT   (2U)
 
#define AIPS_PACRL_SP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRL_SP7_SHIFT)) & AIPS_PACRL_SP7_MASK)
 
#define AIPS_PACRL_TP6_MASK   (0x10U)
 
#define AIPS_PACRL_TP6_SHIFT   (4U)
 
#define AIPS_PACRL_TP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRL_TP6_SHIFT)) & AIPS_PACRL_TP6_MASK)
 
#define AIPS_PACRL_WP6_MASK   (0x20U)
 
#define AIPS_PACRL_WP6_SHIFT   (5U)
 
#define AIPS_PACRL_WP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRL_WP6_SHIFT)) & AIPS_PACRL_WP6_MASK)
 
#define AIPS_PACRL_SP6_MASK   (0x40U)
 
#define AIPS_PACRL_SP6_SHIFT   (6U)
 
#define AIPS_PACRL_SP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRL_SP6_SHIFT)) & AIPS_PACRL_SP6_MASK)
 
#define AIPS_PACRL_TP5_MASK   (0x100U)
 
#define AIPS_PACRL_TP5_SHIFT   (8U)
 
#define AIPS_PACRL_TP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRL_TP5_SHIFT)) & AIPS_PACRL_TP5_MASK)
 
#define AIPS_PACRL_WP5_MASK   (0x200U)
 
#define AIPS_PACRL_WP5_SHIFT   (9U)
 
#define AIPS_PACRL_WP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRL_WP5_SHIFT)) & AIPS_PACRL_WP5_MASK)
 
#define AIPS_PACRL_SP5_MASK   (0x400U)
 
#define AIPS_PACRL_SP5_SHIFT   (10U)
 
#define AIPS_PACRL_SP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRL_SP5_SHIFT)) & AIPS_PACRL_SP5_MASK)
 
#define AIPS_PACRL_TP4_MASK   (0x1000U)
 
#define AIPS_PACRL_TP4_SHIFT   (12U)
 
#define AIPS_PACRL_TP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRL_TP4_SHIFT)) & AIPS_PACRL_TP4_MASK)
 
#define AIPS_PACRL_WP4_MASK   (0x2000U)
 
#define AIPS_PACRL_WP4_SHIFT   (13U)
 
#define AIPS_PACRL_WP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRL_WP4_SHIFT)) & AIPS_PACRL_WP4_MASK)
 
#define AIPS_PACRL_SP4_MASK   (0x4000U)
 
#define AIPS_PACRL_SP4_SHIFT   (14U)
 
#define AIPS_PACRL_SP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRL_SP4_SHIFT)) & AIPS_PACRL_SP4_MASK)
 
#define AIPS_PACRL_TP3_MASK   (0x10000U)
 
#define AIPS_PACRL_TP3_SHIFT   (16U)
 
#define AIPS_PACRL_TP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRL_TP3_SHIFT)) & AIPS_PACRL_TP3_MASK)
 
#define AIPS_PACRL_WP3_MASK   (0x20000U)
 
#define AIPS_PACRL_WP3_SHIFT   (17U)
 
#define AIPS_PACRL_WP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRL_WP3_SHIFT)) & AIPS_PACRL_WP3_MASK)
 
#define AIPS_PACRL_SP3_MASK   (0x40000U)
 
#define AIPS_PACRL_SP3_SHIFT   (18U)
 
#define AIPS_PACRL_SP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRL_SP3_SHIFT)) & AIPS_PACRL_SP3_MASK)
 
#define AIPS_PACRL_TP2_MASK   (0x100000U)
 
#define AIPS_PACRL_TP2_SHIFT   (20U)
 
#define AIPS_PACRL_TP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRL_TP2_SHIFT)) & AIPS_PACRL_TP2_MASK)
 
#define AIPS_PACRL_WP2_MASK   (0x200000U)
 
#define AIPS_PACRL_WP2_SHIFT   (21U)
 
#define AIPS_PACRL_WP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRL_WP2_SHIFT)) & AIPS_PACRL_WP2_MASK)
 
#define AIPS_PACRL_SP2_MASK   (0x400000U)
 
#define AIPS_PACRL_SP2_SHIFT   (22U)
 
#define AIPS_PACRL_SP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRL_SP2_SHIFT)) & AIPS_PACRL_SP2_MASK)
 
#define AIPS_PACRL_TP1_MASK   (0x1000000U)
 
#define AIPS_PACRL_TP1_SHIFT   (24U)
 
#define AIPS_PACRL_TP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRL_TP1_SHIFT)) & AIPS_PACRL_TP1_MASK)
 
#define AIPS_PACRL_WP1_MASK   (0x2000000U)
 
#define AIPS_PACRL_WP1_SHIFT   (25U)
 
#define AIPS_PACRL_WP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRL_WP1_SHIFT)) & AIPS_PACRL_WP1_MASK)
 
#define AIPS_PACRL_SP1_MASK   (0x4000000U)
 
#define AIPS_PACRL_SP1_SHIFT   (26U)
 
#define AIPS_PACRL_SP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRL_SP1_SHIFT)) & AIPS_PACRL_SP1_MASK)
 
#define AIPS_PACRL_TP0_MASK   (0x10000000U)
 
#define AIPS_PACRL_TP0_SHIFT   (28U)
 
#define AIPS_PACRL_TP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRL_TP0_SHIFT)) & AIPS_PACRL_TP0_MASK)
 
#define AIPS_PACRL_WP0_MASK   (0x20000000U)
 
#define AIPS_PACRL_WP0_SHIFT   (29U)
 
#define AIPS_PACRL_WP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRL_WP0_SHIFT)) & AIPS_PACRL_WP0_MASK)
 
#define AIPS_PACRL_SP0_MASK   (0x40000000U)
 
#define AIPS_PACRL_SP0_SHIFT   (30U)
 
#define AIPS_PACRL_SP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRL_SP0_SHIFT)) & AIPS_PACRL_SP0_MASK)
 
PACRM - Peripheral Access Control Register
#define AIPS_PACRM_TP7_MASK   (0x1U)
 
#define AIPS_PACRM_TP7_SHIFT   (0U)
 
#define AIPS_PACRM_TP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRM_TP7_SHIFT)) & AIPS_PACRM_TP7_MASK)
 
#define AIPS_PACRM_WP7_MASK   (0x2U)
 
#define AIPS_PACRM_WP7_SHIFT   (1U)
 
#define AIPS_PACRM_WP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRM_WP7_SHIFT)) & AIPS_PACRM_WP7_MASK)
 
#define AIPS_PACRM_SP7_MASK   (0x4U)
 
#define AIPS_PACRM_SP7_SHIFT   (2U)
 
#define AIPS_PACRM_SP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRM_SP7_SHIFT)) & AIPS_PACRM_SP7_MASK)
 
#define AIPS_PACRM_TP6_MASK   (0x10U)
 
#define AIPS_PACRM_TP6_SHIFT   (4U)
 
#define AIPS_PACRM_TP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRM_TP6_SHIFT)) & AIPS_PACRM_TP6_MASK)
 
#define AIPS_PACRM_WP6_MASK   (0x20U)
 
#define AIPS_PACRM_WP6_SHIFT   (5U)
 
#define AIPS_PACRM_WP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRM_WP6_SHIFT)) & AIPS_PACRM_WP6_MASK)
 
#define AIPS_PACRM_SP6_MASK   (0x40U)
 
#define AIPS_PACRM_SP6_SHIFT   (6U)
 
#define AIPS_PACRM_SP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRM_SP6_SHIFT)) & AIPS_PACRM_SP6_MASK)
 
#define AIPS_PACRM_TP5_MASK   (0x100U)
 
#define AIPS_PACRM_TP5_SHIFT   (8U)
 
#define AIPS_PACRM_TP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRM_TP5_SHIFT)) & AIPS_PACRM_TP5_MASK)
 
#define AIPS_PACRM_WP5_MASK   (0x200U)
 
#define AIPS_PACRM_WP5_SHIFT   (9U)
 
#define AIPS_PACRM_WP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRM_WP5_SHIFT)) & AIPS_PACRM_WP5_MASK)
 
#define AIPS_PACRM_SP5_MASK   (0x400U)
 
#define AIPS_PACRM_SP5_SHIFT   (10U)
 
#define AIPS_PACRM_SP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRM_SP5_SHIFT)) & AIPS_PACRM_SP5_MASK)
 
#define AIPS_PACRM_TP4_MASK   (0x1000U)
 
#define AIPS_PACRM_TP4_SHIFT   (12U)
 
#define AIPS_PACRM_TP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRM_TP4_SHIFT)) & AIPS_PACRM_TP4_MASK)
 
#define AIPS_PACRM_WP4_MASK   (0x2000U)
 
#define AIPS_PACRM_WP4_SHIFT   (13U)
 
#define AIPS_PACRM_WP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRM_WP4_SHIFT)) & AIPS_PACRM_WP4_MASK)
 
#define AIPS_PACRM_SP4_MASK   (0x4000U)
 
#define AIPS_PACRM_SP4_SHIFT   (14U)
 
#define AIPS_PACRM_SP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRM_SP4_SHIFT)) & AIPS_PACRM_SP4_MASK)
 
#define AIPS_PACRM_TP3_MASK   (0x10000U)
 
#define AIPS_PACRM_TP3_SHIFT   (16U)
 
#define AIPS_PACRM_TP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRM_TP3_SHIFT)) & AIPS_PACRM_TP3_MASK)
 
#define AIPS_PACRM_WP3_MASK   (0x20000U)
 
#define AIPS_PACRM_WP3_SHIFT   (17U)
 
#define AIPS_PACRM_WP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRM_WP3_SHIFT)) & AIPS_PACRM_WP3_MASK)
 
#define AIPS_PACRM_SP3_MASK   (0x40000U)
 
#define AIPS_PACRM_SP3_SHIFT   (18U)
 
#define AIPS_PACRM_SP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRM_SP3_SHIFT)) & AIPS_PACRM_SP3_MASK)
 
#define AIPS_PACRM_TP2_MASK   (0x100000U)
 
#define AIPS_PACRM_TP2_SHIFT   (20U)
 
#define AIPS_PACRM_TP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRM_TP2_SHIFT)) & AIPS_PACRM_TP2_MASK)
 
#define AIPS_PACRM_WP2_MASK   (0x200000U)
 
#define AIPS_PACRM_WP2_SHIFT   (21U)
 
#define AIPS_PACRM_WP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRM_WP2_SHIFT)) & AIPS_PACRM_WP2_MASK)
 
#define AIPS_PACRM_SP2_MASK   (0x400000U)
 
#define AIPS_PACRM_SP2_SHIFT   (22U)
 
#define AIPS_PACRM_SP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRM_SP2_SHIFT)) & AIPS_PACRM_SP2_MASK)
 
#define AIPS_PACRM_TP1_MASK   (0x1000000U)
 
#define AIPS_PACRM_TP1_SHIFT   (24U)
 
#define AIPS_PACRM_TP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRM_TP1_SHIFT)) & AIPS_PACRM_TP1_MASK)
 
#define AIPS_PACRM_WP1_MASK   (0x2000000U)
 
#define AIPS_PACRM_WP1_SHIFT   (25U)
 
#define AIPS_PACRM_WP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRM_WP1_SHIFT)) & AIPS_PACRM_WP1_MASK)
 
#define AIPS_PACRM_SP1_MASK   (0x4000000U)
 
#define AIPS_PACRM_SP1_SHIFT   (26U)
 
#define AIPS_PACRM_SP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRM_SP1_SHIFT)) & AIPS_PACRM_SP1_MASK)
 
#define AIPS_PACRM_TP0_MASK   (0x10000000U)
 
#define AIPS_PACRM_TP0_SHIFT   (28U)
 
#define AIPS_PACRM_TP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRM_TP0_SHIFT)) & AIPS_PACRM_TP0_MASK)
 
#define AIPS_PACRM_WP0_MASK   (0x20000000U)
 
#define AIPS_PACRM_WP0_SHIFT   (29U)
 
#define AIPS_PACRM_WP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRM_WP0_SHIFT)) & AIPS_PACRM_WP0_MASK)
 
#define AIPS_PACRM_SP0_MASK   (0x40000000U)
 
#define AIPS_PACRM_SP0_SHIFT   (30U)
 
#define AIPS_PACRM_SP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRM_SP0_SHIFT)) & AIPS_PACRM_SP0_MASK)
 
PACRN - Peripheral Access Control Register
#define AIPS_PACRN_TP7_MASK   (0x1U)
 
#define AIPS_PACRN_TP7_SHIFT   (0U)
 
#define AIPS_PACRN_TP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRN_TP7_SHIFT)) & AIPS_PACRN_TP7_MASK)
 
#define AIPS_PACRN_WP7_MASK   (0x2U)
 
#define AIPS_PACRN_WP7_SHIFT   (1U)
 
#define AIPS_PACRN_WP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRN_WP7_SHIFT)) & AIPS_PACRN_WP7_MASK)
 
#define AIPS_PACRN_SP7_MASK   (0x4U)
 
#define AIPS_PACRN_SP7_SHIFT   (2U)
 
#define AIPS_PACRN_SP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRN_SP7_SHIFT)) & AIPS_PACRN_SP7_MASK)
 
#define AIPS_PACRN_TP6_MASK   (0x10U)
 
#define AIPS_PACRN_TP6_SHIFT   (4U)
 
#define AIPS_PACRN_TP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRN_TP6_SHIFT)) & AIPS_PACRN_TP6_MASK)
 
#define AIPS_PACRN_WP6_MASK   (0x20U)
 
#define AIPS_PACRN_WP6_SHIFT   (5U)
 
#define AIPS_PACRN_WP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRN_WP6_SHIFT)) & AIPS_PACRN_WP6_MASK)
 
#define AIPS_PACRN_SP6_MASK   (0x40U)
 
#define AIPS_PACRN_SP6_SHIFT   (6U)
 
#define AIPS_PACRN_SP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRN_SP6_SHIFT)) & AIPS_PACRN_SP6_MASK)
 
#define AIPS_PACRN_TP5_MASK   (0x100U)
 
#define AIPS_PACRN_TP5_SHIFT   (8U)
 
#define AIPS_PACRN_TP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRN_TP5_SHIFT)) & AIPS_PACRN_TP5_MASK)
 
#define AIPS_PACRN_WP5_MASK   (0x200U)
 
#define AIPS_PACRN_WP5_SHIFT   (9U)
 
#define AIPS_PACRN_WP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRN_WP5_SHIFT)) & AIPS_PACRN_WP5_MASK)
 
#define AIPS_PACRN_SP5_MASK   (0x400U)
 
#define AIPS_PACRN_SP5_SHIFT   (10U)
 
#define AIPS_PACRN_SP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRN_SP5_SHIFT)) & AIPS_PACRN_SP5_MASK)
 
#define AIPS_PACRN_TP4_MASK   (0x1000U)
 
#define AIPS_PACRN_TP4_SHIFT   (12U)
 
#define AIPS_PACRN_TP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRN_TP4_SHIFT)) & AIPS_PACRN_TP4_MASK)
 
#define AIPS_PACRN_WP4_MASK   (0x2000U)
 
#define AIPS_PACRN_WP4_SHIFT   (13U)
 
#define AIPS_PACRN_WP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRN_WP4_SHIFT)) & AIPS_PACRN_WP4_MASK)
 
#define AIPS_PACRN_SP4_MASK   (0x4000U)
 
#define AIPS_PACRN_SP4_SHIFT   (14U)
 
#define AIPS_PACRN_SP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRN_SP4_SHIFT)) & AIPS_PACRN_SP4_MASK)
 
#define AIPS_PACRN_TP3_MASK   (0x10000U)
 
#define AIPS_PACRN_TP3_SHIFT   (16U)
 
#define AIPS_PACRN_TP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRN_TP3_SHIFT)) & AIPS_PACRN_TP3_MASK)
 
#define AIPS_PACRN_WP3_MASK   (0x20000U)
 
#define AIPS_PACRN_WP3_SHIFT   (17U)
 
#define AIPS_PACRN_WP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRN_WP3_SHIFT)) & AIPS_PACRN_WP3_MASK)
 
#define AIPS_PACRN_SP3_MASK   (0x40000U)
 
#define AIPS_PACRN_SP3_SHIFT   (18U)
 
#define AIPS_PACRN_SP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRN_SP3_SHIFT)) & AIPS_PACRN_SP3_MASK)
 
#define AIPS_PACRN_TP2_MASK   (0x100000U)
 
#define AIPS_PACRN_TP2_SHIFT   (20U)
 
#define AIPS_PACRN_TP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRN_TP2_SHIFT)) & AIPS_PACRN_TP2_MASK)
 
#define AIPS_PACRN_WP2_MASK   (0x200000U)
 
#define AIPS_PACRN_WP2_SHIFT   (21U)
 
#define AIPS_PACRN_WP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRN_WP2_SHIFT)) & AIPS_PACRN_WP2_MASK)
 
#define AIPS_PACRN_SP2_MASK   (0x400000U)
 
#define AIPS_PACRN_SP2_SHIFT   (22U)
 
#define AIPS_PACRN_SP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRN_SP2_SHIFT)) & AIPS_PACRN_SP2_MASK)
 
#define AIPS_PACRN_TP1_MASK   (0x1000000U)
 
#define AIPS_PACRN_TP1_SHIFT   (24U)
 
#define AIPS_PACRN_TP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRN_TP1_SHIFT)) & AIPS_PACRN_TP1_MASK)
 
#define AIPS_PACRN_WP1_MASK   (0x2000000U)
 
#define AIPS_PACRN_WP1_SHIFT   (25U)
 
#define AIPS_PACRN_WP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRN_WP1_SHIFT)) & AIPS_PACRN_WP1_MASK)
 
#define AIPS_PACRN_SP1_MASK   (0x4000000U)
 
#define AIPS_PACRN_SP1_SHIFT   (26U)
 
#define AIPS_PACRN_SP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRN_SP1_SHIFT)) & AIPS_PACRN_SP1_MASK)
 
#define AIPS_PACRN_TP0_MASK   (0x10000000U)
 
#define AIPS_PACRN_TP0_SHIFT   (28U)
 
#define AIPS_PACRN_TP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRN_TP0_SHIFT)) & AIPS_PACRN_TP0_MASK)
 
#define AIPS_PACRN_WP0_MASK   (0x20000000U)
 
#define AIPS_PACRN_WP0_SHIFT   (29U)
 
#define AIPS_PACRN_WP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRN_WP0_SHIFT)) & AIPS_PACRN_WP0_MASK)
 
#define AIPS_PACRN_SP0_MASK   (0x40000000U)
 
#define AIPS_PACRN_SP0_SHIFT   (30U)
 
#define AIPS_PACRN_SP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRN_SP0_SHIFT)) & AIPS_PACRN_SP0_MASK)
 
PACRO - Peripheral Access Control Register
#define AIPS_PACRO_TP7_MASK   (0x1U)
 
#define AIPS_PACRO_TP7_SHIFT   (0U)
 
#define AIPS_PACRO_TP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRO_TP7_SHIFT)) & AIPS_PACRO_TP7_MASK)
 
#define AIPS_PACRO_WP7_MASK   (0x2U)
 
#define AIPS_PACRO_WP7_SHIFT   (1U)
 
#define AIPS_PACRO_WP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRO_WP7_SHIFT)) & AIPS_PACRO_WP7_MASK)
 
#define AIPS_PACRO_SP7_MASK   (0x4U)
 
#define AIPS_PACRO_SP7_SHIFT   (2U)
 
#define AIPS_PACRO_SP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRO_SP7_SHIFT)) & AIPS_PACRO_SP7_MASK)
 
#define AIPS_PACRO_TP6_MASK   (0x10U)
 
#define AIPS_PACRO_TP6_SHIFT   (4U)
 
#define AIPS_PACRO_TP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRO_TP6_SHIFT)) & AIPS_PACRO_TP6_MASK)
 
#define AIPS_PACRO_WP6_MASK   (0x20U)
 
#define AIPS_PACRO_WP6_SHIFT   (5U)
 
#define AIPS_PACRO_WP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRO_WP6_SHIFT)) & AIPS_PACRO_WP6_MASK)
 
#define AIPS_PACRO_SP6_MASK   (0x40U)
 
#define AIPS_PACRO_SP6_SHIFT   (6U)
 
#define AIPS_PACRO_SP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRO_SP6_SHIFT)) & AIPS_PACRO_SP6_MASK)
 
#define AIPS_PACRO_TP5_MASK   (0x100U)
 
#define AIPS_PACRO_TP5_SHIFT   (8U)
 
#define AIPS_PACRO_TP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRO_TP5_SHIFT)) & AIPS_PACRO_TP5_MASK)
 
#define AIPS_PACRO_WP5_MASK   (0x200U)
 
#define AIPS_PACRO_WP5_SHIFT   (9U)
 
#define AIPS_PACRO_WP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRO_WP5_SHIFT)) & AIPS_PACRO_WP5_MASK)
 
#define AIPS_PACRO_SP5_MASK   (0x400U)
 
#define AIPS_PACRO_SP5_SHIFT   (10U)
 
#define AIPS_PACRO_SP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRO_SP5_SHIFT)) & AIPS_PACRO_SP5_MASK)
 
#define AIPS_PACRO_TP4_MASK   (0x1000U)
 
#define AIPS_PACRO_TP4_SHIFT   (12U)
 
#define AIPS_PACRO_TP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRO_TP4_SHIFT)) & AIPS_PACRO_TP4_MASK)
 
#define AIPS_PACRO_WP4_MASK   (0x2000U)
 
#define AIPS_PACRO_WP4_SHIFT   (13U)
 
#define AIPS_PACRO_WP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRO_WP4_SHIFT)) & AIPS_PACRO_WP4_MASK)
 
#define AIPS_PACRO_SP4_MASK   (0x4000U)
 
#define AIPS_PACRO_SP4_SHIFT   (14U)
 
#define AIPS_PACRO_SP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRO_SP4_SHIFT)) & AIPS_PACRO_SP4_MASK)
 
#define AIPS_PACRO_TP3_MASK   (0x10000U)
 
#define AIPS_PACRO_TP3_SHIFT   (16U)
 
#define AIPS_PACRO_TP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRO_TP3_SHIFT)) & AIPS_PACRO_TP3_MASK)
 
#define AIPS_PACRO_WP3_MASK   (0x20000U)
 
#define AIPS_PACRO_WP3_SHIFT   (17U)
 
#define AIPS_PACRO_WP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRO_WP3_SHIFT)) & AIPS_PACRO_WP3_MASK)
 
#define AIPS_PACRO_SP3_MASK   (0x40000U)
 
#define AIPS_PACRO_SP3_SHIFT   (18U)
 
#define AIPS_PACRO_SP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRO_SP3_SHIFT)) & AIPS_PACRO_SP3_MASK)
 
#define AIPS_PACRO_TP2_MASK   (0x100000U)
 
#define AIPS_PACRO_TP2_SHIFT   (20U)
 
#define AIPS_PACRO_TP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRO_TP2_SHIFT)) & AIPS_PACRO_TP2_MASK)
 
#define AIPS_PACRO_WP2_MASK   (0x200000U)
 
#define AIPS_PACRO_WP2_SHIFT   (21U)
 
#define AIPS_PACRO_WP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRO_WP2_SHIFT)) & AIPS_PACRO_WP2_MASK)
 
#define AIPS_PACRO_SP2_MASK   (0x400000U)
 
#define AIPS_PACRO_SP2_SHIFT   (22U)
 
#define AIPS_PACRO_SP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRO_SP2_SHIFT)) & AIPS_PACRO_SP2_MASK)
 
#define AIPS_PACRO_TP1_MASK   (0x1000000U)
 
#define AIPS_PACRO_TP1_SHIFT   (24U)
 
#define AIPS_PACRO_TP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRO_TP1_SHIFT)) & AIPS_PACRO_TP1_MASK)
 
#define AIPS_PACRO_WP1_MASK   (0x2000000U)
 
#define AIPS_PACRO_WP1_SHIFT   (25U)
 
#define AIPS_PACRO_WP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRO_WP1_SHIFT)) & AIPS_PACRO_WP1_MASK)
 
#define AIPS_PACRO_SP1_MASK   (0x4000000U)
 
#define AIPS_PACRO_SP1_SHIFT   (26U)
 
#define AIPS_PACRO_SP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRO_SP1_SHIFT)) & AIPS_PACRO_SP1_MASK)
 
#define AIPS_PACRO_TP0_MASK   (0x10000000U)
 
#define AIPS_PACRO_TP0_SHIFT   (28U)
 
#define AIPS_PACRO_TP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRO_TP0_SHIFT)) & AIPS_PACRO_TP0_MASK)
 
#define AIPS_PACRO_WP0_MASK   (0x20000000U)
 
#define AIPS_PACRO_WP0_SHIFT   (29U)
 
#define AIPS_PACRO_WP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRO_WP0_SHIFT)) & AIPS_PACRO_WP0_MASK)
 
#define AIPS_PACRO_SP0_MASK   (0x40000000U)
 
#define AIPS_PACRO_SP0_SHIFT   (30U)
 
#define AIPS_PACRO_SP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRO_SP0_SHIFT)) & AIPS_PACRO_SP0_MASK)
 
PACRP - Peripheral Access Control Register
#define AIPS_PACRP_TP7_MASK   (0x1U)
 
#define AIPS_PACRP_TP7_SHIFT   (0U)
 
#define AIPS_PACRP_TP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRP_TP7_SHIFT)) & AIPS_PACRP_TP7_MASK)
 
#define AIPS_PACRP_WP7_MASK   (0x2U)
 
#define AIPS_PACRP_WP7_SHIFT   (1U)
 
#define AIPS_PACRP_WP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRP_WP7_SHIFT)) & AIPS_PACRP_WP7_MASK)
 
#define AIPS_PACRP_SP7_MASK   (0x4U)
 
#define AIPS_PACRP_SP7_SHIFT   (2U)
 
#define AIPS_PACRP_SP7(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRP_SP7_SHIFT)) & AIPS_PACRP_SP7_MASK)
 
#define AIPS_PACRP_TP6_MASK   (0x10U)
 
#define AIPS_PACRP_TP6_SHIFT   (4U)
 
#define AIPS_PACRP_TP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRP_TP6_SHIFT)) & AIPS_PACRP_TP6_MASK)
 
#define AIPS_PACRP_WP6_MASK   (0x20U)
 
#define AIPS_PACRP_WP6_SHIFT   (5U)
 
#define AIPS_PACRP_WP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRP_WP6_SHIFT)) & AIPS_PACRP_WP6_MASK)
 
#define AIPS_PACRP_SP6_MASK   (0x40U)
 
#define AIPS_PACRP_SP6_SHIFT   (6U)
 
#define AIPS_PACRP_SP6(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRP_SP6_SHIFT)) & AIPS_PACRP_SP6_MASK)
 
#define AIPS_PACRP_TP5_MASK   (0x100U)
 
#define AIPS_PACRP_TP5_SHIFT   (8U)
 
#define AIPS_PACRP_TP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRP_TP5_SHIFT)) & AIPS_PACRP_TP5_MASK)
 
#define AIPS_PACRP_WP5_MASK   (0x200U)
 
#define AIPS_PACRP_WP5_SHIFT   (9U)
 
#define AIPS_PACRP_WP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRP_WP5_SHIFT)) & AIPS_PACRP_WP5_MASK)
 
#define AIPS_PACRP_SP5_MASK   (0x400U)
 
#define AIPS_PACRP_SP5_SHIFT   (10U)
 
#define AIPS_PACRP_SP5(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRP_SP5_SHIFT)) & AIPS_PACRP_SP5_MASK)
 
#define AIPS_PACRP_TP4_MASK   (0x1000U)
 
#define AIPS_PACRP_TP4_SHIFT   (12U)
 
#define AIPS_PACRP_TP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRP_TP4_SHIFT)) & AIPS_PACRP_TP4_MASK)
 
#define AIPS_PACRP_WP4_MASK   (0x2000U)
 
#define AIPS_PACRP_WP4_SHIFT   (13U)
 
#define AIPS_PACRP_WP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRP_WP4_SHIFT)) & AIPS_PACRP_WP4_MASK)
 
#define AIPS_PACRP_SP4_MASK   (0x4000U)
 
#define AIPS_PACRP_SP4_SHIFT   (14U)
 
#define AIPS_PACRP_SP4(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRP_SP4_SHIFT)) & AIPS_PACRP_SP4_MASK)
 
#define AIPS_PACRP_TP3_MASK   (0x10000U)
 
#define AIPS_PACRP_TP3_SHIFT   (16U)
 
#define AIPS_PACRP_TP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRP_TP3_SHIFT)) & AIPS_PACRP_TP3_MASK)
 
#define AIPS_PACRP_WP3_MASK   (0x20000U)
 
#define AIPS_PACRP_WP3_SHIFT   (17U)
 
#define AIPS_PACRP_WP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRP_WP3_SHIFT)) & AIPS_PACRP_WP3_MASK)
 
#define AIPS_PACRP_SP3_MASK   (0x40000U)
 
#define AIPS_PACRP_SP3_SHIFT   (18U)
 
#define AIPS_PACRP_SP3(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRP_SP3_SHIFT)) & AIPS_PACRP_SP3_MASK)
 
#define AIPS_PACRP_TP2_MASK   (0x100000U)
 
#define AIPS_PACRP_TP2_SHIFT   (20U)
 
#define AIPS_PACRP_TP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRP_TP2_SHIFT)) & AIPS_PACRP_TP2_MASK)
 
#define AIPS_PACRP_WP2_MASK   (0x200000U)
 
#define AIPS_PACRP_WP2_SHIFT   (21U)
 
#define AIPS_PACRP_WP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRP_WP2_SHIFT)) & AIPS_PACRP_WP2_MASK)
 
#define AIPS_PACRP_SP2_MASK   (0x400000U)
 
#define AIPS_PACRP_SP2_SHIFT   (22U)
 
#define AIPS_PACRP_SP2(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRP_SP2_SHIFT)) & AIPS_PACRP_SP2_MASK)
 
#define AIPS_PACRP_TP1_MASK   (0x1000000U)
 
#define AIPS_PACRP_TP1_SHIFT   (24U)
 
#define AIPS_PACRP_TP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRP_TP1_SHIFT)) & AIPS_PACRP_TP1_MASK)
 
#define AIPS_PACRP_WP1_MASK   (0x2000000U)
 
#define AIPS_PACRP_WP1_SHIFT   (25U)
 
#define AIPS_PACRP_WP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRP_WP1_SHIFT)) & AIPS_PACRP_WP1_MASK)
 
#define AIPS_PACRP_SP1_MASK   (0x4000000U)
 
#define AIPS_PACRP_SP1_SHIFT   (26U)
 
#define AIPS_PACRP_SP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRP_SP1_SHIFT)) & AIPS_PACRP_SP1_MASK)
 
#define AIPS_PACRP_TP0_MASK   (0x10000000U)
 
#define AIPS_PACRP_TP0_SHIFT   (28U)
 
#define AIPS_PACRP_TP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRP_TP0_SHIFT)) & AIPS_PACRP_TP0_MASK)
 
#define AIPS_PACRP_WP0_MASK   (0x20000000U)
 
#define AIPS_PACRP_WP0_SHIFT   (29U)
 
#define AIPS_PACRP_WP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRP_WP0_SHIFT)) & AIPS_PACRP_WP0_MASK)
 
#define AIPS_PACRP_SP0_MASK   (0x40000000U)
 
#define AIPS_PACRP_SP0_SHIFT   (30U)
 
#define AIPS_PACRP_SP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRP_SP0_SHIFT)) & AIPS_PACRP_SP0_MASK)
 
PACRU - Peripheral Access Control Register
#define AIPS_PACRU_TP1_MASK   (0x1000000U)
 
#define AIPS_PACRU_TP1_SHIFT   (24U)
 
#define AIPS_PACRU_TP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRU_TP1_SHIFT)) & AIPS_PACRU_TP1_MASK)
 
#define AIPS_PACRU_WP1_MASK   (0x2000000U)
 
#define AIPS_PACRU_WP1_SHIFT   (25U)
 
#define AIPS_PACRU_WP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRU_WP1_SHIFT)) & AIPS_PACRU_WP1_MASK)
 
#define AIPS_PACRU_SP1_MASK   (0x4000000U)
 
#define AIPS_PACRU_SP1_SHIFT   (26U)
 
#define AIPS_PACRU_SP1(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRU_SP1_SHIFT)) & AIPS_PACRU_SP1_MASK)
 
#define AIPS_PACRU_TP0_MASK   (0x10000000U)
 
#define AIPS_PACRU_TP0_SHIFT   (28U)
 
#define AIPS_PACRU_TP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRU_TP0_SHIFT)) & AIPS_PACRU_TP0_MASK)
 
#define AIPS_PACRU_WP0_MASK   (0x20000000U)
 
#define AIPS_PACRU_WP0_SHIFT   (29U)
 
#define AIPS_PACRU_WP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRU_WP0_SHIFT)) & AIPS_PACRU_WP0_MASK)
 
#define AIPS_PACRU_SP0_MASK   (0x40000000U)
 
#define AIPS_PACRU_SP0_SHIFT   (30U)
 
#define AIPS_PACRU_SP0(x)   (((uint32_t)(((uint32_t)(x)) << AIPS_PACRU_SP0_SHIFT)) & AIPS_PACRU_SP0_MASK)
 
PRS - Priority Registers Slave
#define AXBS_PRS_M0_MASK   (0x7U)
 
#define AXBS_PRS_M0_SHIFT   (0U)
 
#define AXBS_PRS_M0(x)   (((uint32_t)(((uint32_t)(x)) << AXBS_PRS_M0_SHIFT)) & AXBS_PRS_M0_MASK)
 
#define AXBS_PRS_M1_MASK   (0x70U)
 
#define AXBS_PRS_M1_SHIFT   (4U)
 
#define AXBS_PRS_M1(x)   (((uint32_t)(((uint32_t)(x)) << AXBS_PRS_M1_SHIFT)) & AXBS_PRS_M1_MASK)
 
#define AXBS_PRS_M2_MASK   (0x700U)
 
#define AXBS_PRS_M2_SHIFT   (8U)
 
#define AXBS_PRS_M2(x)   (((uint32_t)(((uint32_t)(x)) << AXBS_PRS_M2_SHIFT)) & AXBS_PRS_M2_MASK)
 
#define AXBS_PRS_M3_MASK   (0x7000U)
 
#define AXBS_PRS_M3_SHIFT   (12U)
 
#define AXBS_PRS_M3(x)   (((uint32_t)(((uint32_t)(x)) << AXBS_PRS_M3_SHIFT)) & AXBS_PRS_M3_MASK)
 
#define AXBS_PRS_M4_MASK   (0x70000U)
 
#define AXBS_PRS_M4_SHIFT   (16U)
 
#define AXBS_PRS_M4(x)   (((uint32_t)(((uint32_t)(x)) << AXBS_PRS_M4_SHIFT)) & AXBS_PRS_M4_MASK)
 
#define AXBS_PRS_M5_MASK   (0x700000U)
 
#define AXBS_PRS_M5_SHIFT   (20U)
 
#define AXBS_PRS_M5(x)   (((uint32_t)(((uint32_t)(x)) << AXBS_PRS_M5_SHIFT)) & AXBS_PRS_M5_MASK)
 
#define AXBS_PRS_COUNT   (5U)
 
CRS - Control Register
#define AXBS_CRS_PARK_MASK   (0x7U)
 
#define AXBS_CRS_PARK_SHIFT   (0U)
 
#define AXBS_CRS_PARK(x)   (((uint32_t)(((uint32_t)(x)) << AXBS_CRS_PARK_SHIFT)) & AXBS_CRS_PARK_MASK)
 
#define AXBS_CRS_PCTL_MASK   (0x30U)
 
#define AXBS_CRS_PCTL_SHIFT   (4U)
 
#define AXBS_CRS_PCTL(x)   (((uint32_t)(((uint32_t)(x)) << AXBS_CRS_PCTL_SHIFT)) & AXBS_CRS_PCTL_MASK)
 
#define AXBS_CRS_ARB_MASK   (0x300U)
 
#define AXBS_CRS_ARB_SHIFT   (8U)
 
#define AXBS_CRS_ARB(x)   (((uint32_t)(((uint32_t)(x)) << AXBS_CRS_ARB_SHIFT)) & AXBS_CRS_ARB_MASK)
 
#define AXBS_CRS_HLP_MASK   (0x40000000U)
 
#define AXBS_CRS_HLP_SHIFT   (30U)
 
#define AXBS_CRS_HLP(x)   (((uint32_t)(((uint32_t)(x)) << AXBS_CRS_HLP_SHIFT)) & AXBS_CRS_HLP_MASK)
 
#define AXBS_CRS_RO_MASK   (0x80000000U)
 
#define AXBS_CRS_RO_SHIFT   (31U)
 
#define AXBS_CRS_RO(x)   (((uint32_t)(((uint32_t)(x)) << AXBS_CRS_RO_SHIFT)) & AXBS_CRS_RO_MASK)
 
#define AXBS_CRS_COUNT   (5U)
 
MGPCR0 - Master General Purpose Control Register
#define AXBS_MGPCR0_AULB_MASK   (0x7U)
 
#define AXBS_MGPCR0_AULB_SHIFT   (0U)
 
#define AXBS_MGPCR0_AULB(x)   (((uint32_t)(((uint32_t)(x)) << AXBS_MGPCR0_AULB_SHIFT)) & AXBS_MGPCR0_AULB_MASK)
 
MGPCR1 - Master General Purpose Control Register
#define AXBS_MGPCR1_AULB_MASK   (0x7U)
 
#define AXBS_MGPCR1_AULB_SHIFT   (0U)
 
#define AXBS_MGPCR1_AULB(x)   (((uint32_t)(((uint32_t)(x)) << AXBS_MGPCR1_AULB_SHIFT)) & AXBS_MGPCR1_AULB_MASK)
 
MGPCR2 - Master General Purpose Control Register
#define AXBS_MGPCR2_AULB_MASK   (0x7U)
 
#define AXBS_MGPCR2_AULB_SHIFT   (0U)
 
#define AXBS_MGPCR2_AULB(x)   (((uint32_t)(((uint32_t)(x)) << AXBS_MGPCR2_AULB_SHIFT)) & AXBS_MGPCR2_AULB_MASK)
 
MGPCR3 - Master General Purpose Control Register
#define AXBS_MGPCR3_AULB_MASK   (0x7U)
 
#define AXBS_MGPCR3_AULB_SHIFT   (0U)
 
#define AXBS_MGPCR3_AULB(x)   (((uint32_t)(((uint32_t)(x)) << AXBS_MGPCR3_AULB_SHIFT)) & AXBS_MGPCR3_AULB_MASK)
 
MGPCR4 - Master General Purpose Control Register
#define AXBS_MGPCR4_AULB_MASK   (0x7U)
 
#define AXBS_MGPCR4_AULB_SHIFT   (0U)
 
#define AXBS_MGPCR4_AULB(x)   (((uint32_t)(((uint32_t)(x)) << AXBS_MGPCR4_AULB_SHIFT)) & AXBS_MGPCR4_AULB_MASK)
 
MGPCR5 - Master General Purpose Control Register
#define AXBS_MGPCR5_AULB_MASK   (0x7U)
 
#define AXBS_MGPCR5_AULB_SHIFT   (0U)
 
#define AXBS_MGPCR5_AULB(x)   (((uint32_t)(((uint32_t)(x)) << AXBS_MGPCR5_AULB_SHIFT)) & AXBS_MGPCR5_AULB_MASK)
 
MCR - Module Configuration Register
#define CAN_MCR_MAXMB_MASK   (0x7FU)
 
#define CAN_MCR_MAXMB_SHIFT   (0U)
 
#define CAN_MCR_MAXMB(x)   (((uint32_t)(((uint32_t)(x)) << CAN_MCR_MAXMB_SHIFT)) & CAN_MCR_MAXMB_MASK)
 
#define CAN_MCR_IDAM_MASK   (0x300U)
 
#define CAN_MCR_IDAM_SHIFT   (8U)
 
#define CAN_MCR_IDAM(x)   (((uint32_t)(((uint32_t)(x)) << CAN_MCR_IDAM_SHIFT)) & CAN_MCR_IDAM_MASK)
 
#define CAN_MCR_AEN_MASK   (0x1000U)
 
#define CAN_MCR_AEN_SHIFT   (12U)
 
#define CAN_MCR_AEN(x)   (((uint32_t)(((uint32_t)(x)) << CAN_MCR_AEN_SHIFT)) & CAN_MCR_AEN_MASK)
 
#define CAN_MCR_LPRIOEN_MASK   (0x2000U)
 
#define CAN_MCR_LPRIOEN_SHIFT   (13U)
 
#define CAN_MCR_LPRIOEN(x)   (((uint32_t)(((uint32_t)(x)) << CAN_MCR_LPRIOEN_SHIFT)) & CAN_MCR_LPRIOEN_MASK)
 
#define CAN_MCR_IRMQ_MASK   (0x10000U)
 
#define CAN_MCR_IRMQ_SHIFT   (16U)
 
#define CAN_MCR_IRMQ(x)   (((uint32_t)(((uint32_t)(x)) << CAN_MCR_IRMQ_SHIFT)) & CAN_MCR_IRMQ_MASK)
 
#define CAN_MCR_SRXDIS_MASK   (0x20000U)
 
#define CAN_MCR_SRXDIS_SHIFT   (17U)
 
#define CAN_MCR_SRXDIS(x)   (((uint32_t)(((uint32_t)(x)) << CAN_MCR_SRXDIS_SHIFT)) & CAN_MCR_SRXDIS_MASK)
 
#define CAN_MCR_WAKSRC_MASK   (0x80000U)
 
#define CAN_MCR_WAKSRC_SHIFT   (19U)
 
#define CAN_MCR_WAKSRC(x)   (((uint32_t)(((uint32_t)(x)) << CAN_MCR_WAKSRC_SHIFT)) & CAN_MCR_WAKSRC_MASK)
 
#define CAN_MCR_LPMACK_MASK   (0x100000U)
 
#define CAN_MCR_LPMACK_SHIFT   (20U)
 
#define CAN_MCR_LPMACK(x)   (((uint32_t)(((uint32_t)(x)) << CAN_MCR_LPMACK_SHIFT)) & CAN_MCR_LPMACK_MASK)
 
#define CAN_MCR_WRNEN_MASK   (0x200000U)
 
#define CAN_MCR_WRNEN_SHIFT   (21U)
 
#define CAN_MCR_WRNEN(x)   (((uint32_t)(((uint32_t)(x)) << CAN_MCR_WRNEN_SHIFT)) & CAN_MCR_WRNEN_MASK)
 
#define CAN_MCR_SLFWAK_MASK   (0x400000U)
 
#define CAN_MCR_SLFWAK_SHIFT   (22U)
 
#define CAN_MCR_SLFWAK(x)   (((uint32_t)(((uint32_t)(x)) << CAN_MCR_SLFWAK_SHIFT)) & CAN_MCR_SLFWAK_MASK)
 
#define CAN_MCR_SUPV_MASK   (0x800000U)
 
#define CAN_MCR_SUPV_SHIFT   (23U)
 
#define CAN_MCR_SUPV(x)   (((uint32_t)(((uint32_t)(x)) << CAN_MCR_SUPV_SHIFT)) & CAN_MCR_SUPV_MASK)
 
#define CAN_MCR_FRZACK_MASK   (0x1000000U)
 
#define CAN_MCR_FRZACK_SHIFT   (24U)
 
#define CAN_MCR_FRZACK(x)   (((uint32_t)(((uint32_t)(x)) << CAN_MCR_FRZACK_SHIFT)) & CAN_MCR_FRZACK_MASK)
 
#define CAN_MCR_SOFTRST_MASK   (0x2000000U)
 
#define CAN_MCR_SOFTRST_SHIFT   (25U)
 
#define CAN_MCR_SOFTRST(x)   (((uint32_t)(((uint32_t)(x)) << CAN_MCR_SOFTRST_SHIFT)) & CAN_MCR_SOFTRST_MASK)
 
#define CAN_MCR_WAKMSK_MASK   (0x4000000U)
 
#define CAN_MCR_WAKMSK_SHIFT   (26U)
 
#define CAN_MCR_WAKMSK(x)   (((uint32_t)(((uint32_t)(x)) << CAN_MCR_WAKMSK_SHIFT)) & CAN_MCR_WAKMSK_MASK)
 
#define CAN_MCR_NOTRDY_MASK   (0x8000000U)
 
#define CAN_MCR_NOTRDY_SHIFT   (27U)
 
#define CAN_MCR_NOTRDY(x)   (((uint32_t)(((uint32_t)(x)) << CAN_MCR_NOTRDY_SHIFT)) & CAN_MCR_NOTRDY_MASK)
 
#define CAN_MCR_HALT_MASK   (0x10000000U)
 
#define CAN_MCR_HALT_SHIFT   (28U)
 
#define CAN_MCR_HALT(x)   (((uint32_t)(((uint32_t)(x)) << CAN_MCR_HALT_SHIFT)) & CAN_MCR_HALT_MASK)
 
#define CAN_MCR_RFEN_MASK   (0x20000000U)
 
#define CAN_MCR_RFEN_SHIFT   (29U)
 
#define CAN_MCR_RFEN(x)   (((uint32_t)(((uint32_t)(x)) << CAN_MCR_RFEN_SHIFT)) & CAN_MCR_RFEN_MASK)
 
#define CAN_MCR_FRZ_MASK   (0x40000000U)
 
#define CAN_MCR_FRZ_SHIFT   (30U)
 
#define CAN_MCR_FRZ(x)   (((uint32_t)(((uint32_t)(x)) << CAN_MCR_FRZ_SHIFT)) & CAN_MCR_FRZ_MASK)
 
#define CAN_MCR_MDIS_MASK   (0x80000000U)
 
#define CAN_MCR_MDIS_SHIFT   (31U)
 
#define CAN_MCR_MDIS(x)   (((uint32_t)(((uint32_t)(x)) << CAN_MCR_MDIS_SHIFT)) & CAN_MCR_MDIS_MASK)
 
#define SPI_MCR_HALT_MASK   (0x1U)
 
#define SPI_MCR_HALT_SHIFT   (0U)
 
#define SPI_MCR_HALT(x)   (((uint32_t)(((uint32_t)(x)) << SPI_MCR_HALT_SHIFT)) & SPI_MCR_HALT_MASK)
 
#define SPI_MCR_SMPL_PT_MASK   (0x300U)
 
#define SPI_MCR_SMPL_PT_SHIFT   (8U)
 
#define SPI_MCR_SMPL_PT(x)   (((uint32_t)(((uint32_t)(x)) << SPI_MCR_SMPL_PT_SHIFT)) & SPI_MCR_SMPL_PT_MASK)
 
#define SPI_MCR_CLR_RXF_MASK   (0x400U)
 
#define SPI_MCR_CLR_RXF_SHIFT   (10U)
 
#define SPI_MCR_CLR_RXF(x)   (((uint32_t)(((uint32_t)(x)) << SPI_MCR_CLR_RXF_SHIFT)) & SPI_MCR_CLR_RXF_MASK)
 
#define SPI_MCR_CLR_TXF_MASK   (0x800U)
 
#define SPI_MCR_CLR_TXF_SHIFT   (11U)
 
#define SPI_MCR_CLR_TXF(x)   (((uint32_t)(((uint32_t)(x)) << SPI_MCR_CLR_TXF_SHIFT)) & SPI_MCR_CLR_TXF_MASK)
 
#define SPI_MCR_DIS_RXF_MASK   (0x1000U)
 
#define SPI_MCR_DIS_RXF_SHIFT   (12U)
 
#define SPI_MCR_DIS_RXF(x)   (((uint32_t)(((uint32_t)(x)) << SPI_MCR_DIS_RXF_SHIFT)) & SPI_MCR_DIS_RXF_MASK)
 
#define SPI_MCR_DIS_TXF_MASK   (0x2000U)
 
#define SPI_MCR_DIS_TXF_SHIFT   (13U)
 
#define SPI_MCR_DIS_TXF(x)   (((uint32_t)(((uint32_t)(x)) << SPI_MCR_DIS_TXF_SHIFT)) & SPI_MCR_DIS_TXF_MASK)
 
#define SPI_MCR_MDIS_MASK   (0x4000U)
 
#define SPI_MCR_MDIS_SHIFT   (14U)
 
#define SPI_MCR_MDIS(x)   (((uint32_t)(((uint32_t)(x)) << SPI_MCR_MDIS_SHIFT)) & SPI_MCR_MDIS_MASK)
 
#define SPI_MCR_DOZE_MASK   (0x8000U)
 
#define SPI_MCR_DOZE_SHIFT   (15U)
 
#define SPI_MCR_DOZE(x)   (((uint32_t)(((uint32_t)(x)) << SPI_MCR_DOZE_SHIFT)) & SPI_MCR_DOZE_MASK)
 
#define SPI_MCR_PCSIS_MASK   (0x3F0000U)
 
#define SPI_MCR_PCSIS_SHIFT   (16U)
 
#define SPI_MCR_PCSIS(x)   (((uint32_t)(((uint32_t)(x)) << SPI_MCR_PCSIS_SHIFT)) & SPI_MCR_PCSIS_MASK)
 
#define SPI_MCR_ROOE_MASK   (0x1000000U)
 
#define SPI_MCR_ROOE_SHIFT   (24U)
 
#define SPI_MCR_ROOE(x)   (((uint32_t)(((uint32_t)(x)) << SPI_MCR_ROOE_SHIFT)) & SPI_MCR_ROOE_MASK)
 
#define SPI_MCR_PCSSE_MASK   (0x2000000U)
 
#define SPI_MCR_PCSSE_SHIFT   (25U)
 
#define SPI_MCR_PCSSE(x)   (((uint32_t)(((uint32_t)(x)) << SPI_MCR_PCSSE_SHIFT)) & SPI_MCR_PCSSE_MASK)
 
#define SPI_MCR_MTFE_MASK   (0x4000000U)
 
#define SPI_MCR_MTFE_SHIFT   (26U)
 
#define SPI_MCR_MTFE(x)   (((uint32_t)(((uint32_t)(x)) << SPI_MCR_MTFE_SHIFT)) & SPI_MCR_MTFE_MASK)
 
#define SPI_MCR_FRZ_MASK   (0x8000000U)
 
#define SPI_MCR_FRZ_SHIFT   (27U)
 
#define SPI_MCR_FRZ(x)   (((uint32_t)(((uint32_t)(x)) << SPI_MCR_FRZ_SHIFT)) & SPI_MCR_FRZ_MASK)
 
#define SPI_MCR_DCONF_MASK   (0x30000000U)
 
#define SPI_MCR_DCONF_SHIFT   (28U)
 
#define SPI_MCR_DCONF(x)   (((uint32_t)(((uint32_t)(x)) << SPI_MCR_DCONF_SHIFT)) & SPI_MCR_DCONF_MASK)
 
#define SPI_MCR_CONT_SCKE_MASK   (0x40000000U)
 
#define SPI_MCR_CONT_SCKE_SHIFT   (30U)
 
#define SPI_MCR_CONT_SCKE(x)   (((uint32_t)(((uint32_t)(x)) << SPI_MCR_CONT_SCKE_SHIFT)) & SPI_MCR_CONT_SCKE_MASK)
 
#define SPI_MCR_MSTR_MASK   (0x80000000U)
 
#define SPI_MCR_MSTR_SHIFT   (31U)
 
#define SPI_MCR_MSTR(x)   (((uint32_t)(((uint32_t)(x)) << SPI_MCR_MSTR_SHIFT)) & SPI_MCR_MSTR_MASK)
 
CTRL1 - Control 1 register
#define CAN_CTRL1_PROPSEG_MASK   (0x7U)
 
#define CAN_CTRL1_PROPSEG_SHIFT   (0U)
 
#define CAN_CTRL1_PROPSEG(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CTRL1_PROPSEG_SHIFT)) & CAN_CTRL1_PROPSEG_MASK)
 
#define CAN_CTRL1_LOM_MASK   (0x8U)
 
#define CAN_CTRL1_LOM_SHIFT   (3U)
 
#define CAN_CTRL1_LOM(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CTRL1_LOM_SHIFT)) & CAN_CTRL1_LOM_MASK)
 
#define CAN_CTRL1_LBUF_MASK   (0x10U)
 
#define CAN_CTRL1_LBUF_SHIFT   (4U)
 
#define CAN_CTRL1_LBUF(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CTRL1_LBUF_SHIFT)) & CAN_CTRL1_LBUF_MASK)
 
#define CAN_CTRL1_TSYN_MASK   (0x20U)
 
#define CAN_CTRL1_TSYN_SHIFT   (5U)
 
#define CAN_CTRL1_TSYN(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CTRL1_TSYN_SHIFT)) & CAN_CTRL1_TSYN_MASK)
 
#define CAN_CTRL1_BOFFREC_MASK   (0x40U)
 
#define CAN_CTRL1_BOFFREC_SHIFT   (6U)
 
#define CAN_CTRL1_BOFFREC(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CTRL1_BOFFREC_SHIFT)) & CAN_CTRL1_BOFFREC_MASK)
 
#define CAN_CTRL1_SMP_MASK   (0x80U)
 
#define CAN_CTRL1_SMP_SHIFT   (7U)
 
#define CAN_CTRL1_SMP(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CTRL1_SMP_SHIFT)) & CAN_CTRL1_SMP_MASK)
 
#define CAN_CTRL1_RWRNMSK_MASK   (0x400U)
 
#define CAN_CTRL1_RWRNMSK_SHIFT   (10U)
 
#define CAN_CTRL1_RWRNMSK(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CTRL1_RWRNMSK_SHIFT)) & CAN_CTRL1_RWRNMSK_MASK)
 
#define CAN_CTRL1_TWRNMSK_MASK   (0x800U)
 
#define CAN_CTRL1_TWRNMSK_SHIFT   (11U)
 
#define CAN_CTRL1_TWRNMSK(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CTRL1_TWRNMSK_SHIFT)) & CAN_CTRL1_TWRNMSK_MASK)
 
#define CAN_CTRL1_LPB_MASK   (0x1000U)
 
#define CAN_CTRL1_LPB_SHIFT   (12U)
 
#define CAN_CTRL1_LPB(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CTRL1_LPB_SHIFT)) & CAN_CTRL1_LPB_MASK)
 
#define CAN_CTRL1_CLKSRC_MASK   (0x2000U)
 
#define CAN_CTRL1_CLKSRC_SHIFT   (13U)
 
#define CAN_CTRL1_CLKSRC(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CTRL1_CLKSRC_SHIFT)) & CAN_CTRL1_CLKSRC_MASK)
 
#define CAN_CTRL1_ERRMSK_MASK   (0x4000U)
 
#define CAN_CTRL1_ERRMSK_SHIFT   (14U)
 
#define CAN_CTRL1_ERRMSK(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CTRL1_ERRMSK_SHIFT)) & CAN_CTRL1_ERRMSK_MASK)
 
#define CAN_CTRL1_BOFFMSK_MASK   (0x8000U)
 
#define CAN_CTRL1_BOFFMSK_SHIFT   (15U)
 
#define CAN_CTRL1_BOFFMSK(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CTRL1_BOFFMSK_SHIFT)) & CAN_CTRL1_BOFFMSK_MASK)
 
#define CAN_CTRL1_PSEG2_MASK   (0x70000U)
 
#define CAN_CTRL1_PSEG2_SHIFT   (16U)
 
#define CAN_CTRL1_PSEG2(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CTRL1_PSEG2_SHIFT)) & CAN_CTRL1_PSEG2_MASK)
 
#define CAN_CTRL1_PSEG1_MASK   (0x380000U)
 
#define CAN_CTRL1_PSEG1_SHIFT   (19U)
 
#define CAN_CTRL1_PSEG1(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CTRL1_PSEG1_SHIFT)) & CAN_CTRL1_PSEG1_MASK)
 
#define CAN_CTRL1_RJW_MASK   (0xC00000U)
 
#define CAN_CTRL1_RJW_SHIFT   (22U)
 
#define CAN_CTRL1_RJW(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CTRL1_RJW_SHIFT)) & CAN_CTRL1_RJW_MASK)
 
#define CAN_CTRL1_PRESDIV_MASK   (0xFF000000U)
 
#define CAN_CTRL1_PRESDIV_SHIFT   (24U)
 
#define CAN_CTRL1_PRESDIV(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CTRL1_PRESDIV_SHIFT)) & CAN_CTRL1_PRESDIV_MASK)
 
TIMER - Free Running Timer
#define CAN_TIMER_TIMER_MASK   (0xFFFFU)
 
#define CAN_TIMER_TIMER_SHIFT   (0U)
 
#define CAN_TIMER_TIMER(x)   (((uint32_t)(((uint32_t)(x)) << CAN_TIMER_TIMER_SHIFT)) & CAN_TIMER_TIMER_MASK)
 
RXMGMASK - Rx Mailboxes Global Mask Register
#define CAN_RXMGMASK_MG_MASK   (0xFFFFFFFFU)
 
#define CAN_RXMGMASK_MG_SHIFT   (0U)
 
#define CAN_RXMGMASK_MG(x)   (((uint32_t)(((uint32_t)(x)) << CAN_RXMGMASK_MG_SHIFT)) & CAN_RXMGMASK_MG_MASK)
 
RX14MASK - Rx 14 Mask register
#define CAN_RX14MASK_RX14M_MASK   (0xFFFFFFFFU)
 
#define CAN_RX14MASK_RX14M_SHIFT   (0U)
 
#define CAN_RX14MASK_RX14M(x)   (((uint32_t)(((uint32_t)(x)) << CAN_RX14MASK_RX14M_SHIFT)) & CAN_RX14MASK_RX14M_MASK)
 
RX15MASK - Rx 15 Mask register
#define CAN_RX15MASK_RX15M_MASK   (0xFFFFFFFFU)
 
#define CAN_RX15MASK_RX15M_SHIFT   (0U)
 
#define CAN_RX15MASK_RX15M(x)   (((uint32_t)(((uint32_t)(x)) << CAN_RX15MASK_RX15M_SHIFT)) & CAN_RX15MASK_RX15M_MASK)
 
ECR - Error Counter
#define CAN_ECR_TXERRCNT_MASK   (0xFFU)
 
#define CAN_ECR_TXERRCNT_SHIFT   (0U)
 
#define CAN_ECR_TXERRCNT(x)   (((uint32_t)(((uint32_t)(x)) << CAN_ECR_TXERRCNT_SHIFT)) & CAN_ECR_TXERRCNT_MASK)
 
#define CAN_ECR_RXERRCNT_MASK   (0xFF00U)
 
#define CAN_ECR_RXERRCNT_SHIFT   (8U)
 
#define CAN_ECR_RXERRCNT(x)   (((uint32_t)(((uint32_t)(x)) << CAN_ECR_RXERRCNT_SHIFT)) & CAN_ECR_RXERRCNT_MASK)
 
ESR1 - Error and Status 1 register
#define CAN_ESR1_WAKINT_MASK   (0x1U)
 
#define CAN_ESR1_WAKINT_SHIFT   (0U)
 
#define CAN_ESR1_WAKINT(x)   (((uint32_t)(((uint32_t)(x)) << CAN_ESR1_WAKINT_SHIFT)) & CAN_ESR1_WAKINT_MASK)
 
#define CAN_ESR1_ERRINT_MASK   (0x2U)
 
#define CAN_ESR1_ERRINT_SHIFT   (1U)
 
#define CAN_ESR1_ERRINT(x)   (((uint32_t)(((uint32_t)(x)) << CAN_ESR1_ERRINT_SHIFT)) & CAN_ESR1_ERRINT_MASK)
 
#define CAN_ESR1_BOFFINT_MASK   (0x4U)
 
#define CAN_ESR1_BOFFINT_SHIFT   (2U)
 
#define CAN_ESR1_BOFFINT(x)   (((uint32_t)(((uint32_t)(x)) << CAN_ESR1_BOFFINT_SHIFT)) & CAN_ESR1_BOFFINT_MASK)
 
#define CAN_ESR1_RX_MASK   (0x8U)
 
#define CAN_ESR1_RX_SHIFT   (3U)
 
#define CAN_ESR1_RX(x)   (((uint32_t)(((uint32_t)(x)) << CAN_ESR1_RX_SHIFT)) & CAN_ESR1_RX_MASK)
 
#define CAN_ESR1_FLTCONF_MASK   (0x30U)
 
#define CAN_ESR1_FLTCONF_SHIFT   (4U)
 
#define CAN_ESR1_FLTCONF(x)   (((uint32_t)(((uint32_t)(x)) << CAN_ESR1_FLTCONF_SHIFT)) & CAN_ESR1_FLTCONF_MASK)
 
#define CAN_ESR1_TX_MASK   (0x40U)
 
#define CAN_ESR1_TX_SHIFT   (6U)
 
#define CAN_ESR1_TX(x)   (((uint32_t)(((uint32_t)(x)) << CAN_ESR1_TX_SHIFT)) & CAN_ESR1_TX_MASK)
 
#define CAN_ESR1_IDLE_MASK   (0x80U)
 
#define CAN_ESR1_IDLE_SHIFT   (7U)
 
#define CAN_ESR1_IDLE(x)   (((uint32_t)(((uint32_t)(x)) << CAN_ESR1_IDLE_SHIFT)) & CAN_ESR1_IDLE_MASK)
 
#define CAN_ESR1_RXWRN_MASK   (0x100U)
 
#define CAN_ESR1_RXWRN_SHIFT   (8U)
 
#define CAN_ESR1_RXWRN(x)   (((uint32_t)(((uint32_t)(x)) << CAN_ESR1_RXWRN_SHIFT)) & CAN_ESR1_RXWRN_MASK)
 
#define CAN_ESR1_TXWRN_MASK   (0x200U)
 
#define CAN_ESR1_TXWRN_SHIFT   (9U)
 
#define CAN_ESR1_TXWRN(x)   (((uint32_t)(((uint32_t)(x)) << CAN_ESR1_TXWRN_SHIFT)) & CAN_ESR1_TXWRN_MASK)
 
#define CAN_ESR1_STFERR_MASK   (0x400U)
 
#define CAN_ESR1_STFERR_SHIFT   (10U)
 
#define CAN_ESR1_STFERR(x)   (((uint32_t)(((uint32_t)(x)) << CAN_ESR1_STFERR_SHIFT)) & CAN_ESR1_STFERR_MASK)
 
#define CAN_ESR1_FRMERR_MASK   (0x800U)
 
#define CAN_ESR1_FRMERR_SHIFT   (11U)
 
#define CAN_ESR1_FRMERR(x)   (((uint32_t)(((uint32_t)(x)) << CAN_ESR1_FRMERR_SHIFT)) & CAN_ESR1_FRMERR_MASK)
 
#define CAN_ESR1_CRCERR_MASK   (0x1000U)
 
#define CAN_ESR1_CRCERR_SHIFT   (12U)
 
#define CAN_ESR1_CRCERR(x)   (((uint32_t)(((uint32_t)(x)) << CAN_ESR1_CRCERR_SHIFT)) & CAN_ESR1_CRCERR_MASK)
 
#define CAN_ESR1_ACKERR_MASK   (0x2000U)
 
#define CAN_ESR1_ACKERR_SHIFT   (13U)
 
#define CAN_ESR1_ACKERR(x)   (((uint32_t)(((uint32_t)(x)) << CAN_ESR1_ACKERR_SHIFT)) & CAN_ESR1_ACKERR_MASK)
 
#define CAN_ESR1_BIT0ERR_MASK   (0x4000U)
 
#define CAN_ESR1_BIT0ERR_SHIFT   (14U)
 
#define CAN_ESR1_BIT0ERR(x)   (((uint32_t)(((uint32_t)(x)) << CAN_ESR1_BIT0ERR_SHIFT)) & CAN_ESR1_BIT0ERR_MASK)
 
#define CAN_ESR1_BIT1ERR_MASK   (0x8000U)
 
#define CAN_ESR1_BIT1ERR_SHIFT   (15U)
 
#define CAN_ESR1_BIT1ERR(x)   (((uint32_t)(((uint32_t)(x)) << CAN_ESR1_BIT1ERR_SHIFT)) & CAN_ESR1_BIT1ERR_MASK)
 
#define CAN_ESR1_RWRNINT_MASK   (0x10000U)
 
#define CAN_ESR1_RWRNINT_SHIFT   (16U)
 
#define CAN_ESR1_RWRNINT(x)   (((uint32_t)(((uint32_t)(x)) << CAN_ESR1_RWRNINT_SHIFT)) & CAN_ESR1_RWRNINT_MASK)
 
#define CAN_ESR1_TWRNINT_MASK   (0x20000U)
 
#define CAN_ESR1_TWRNINT_SHIFT   (17U)
 
#define CAN_ESR1_TWRNINT(x)   (((uint32_t)(((uint32_t)(x)) << CAN_ESR1_TWRNINT_SHIFT)) & CAN_ESR1_TWRNINT_MASK)
 
#define CAN_ESR1_SYNCH_MASK   (0x40000U)
 
#define CAN_ESR1_SYNCH_SHIFT   (18U)
 
#define CAN_ESR1_SYNCH(x)   (((uint32_t)(((uint32_t)(x)) << CAN_ESR1_SYNCH_SHIFT)) & CAN_ESR1_SYNCH_MASK)
 
IMASK1 - Interrupt Masks 1 register
#define CAN_IMASK1_BUFLM_MASK   (0xFFFFFFFFU)
 
#define CAN_IMASK1_BUFLM_SHIFT   (0U)
 
#define CAN_IMASK1_BUFLM(x)   (((uint32_t)(((uint32_t)(x)) << CAN_IMASK1_BUFLM_SHIFT)) & CAN_IMASK1_BUFLM_MASK)
 
IFLAG1 - Interrupt Flags 1 register
#define CAN_IFLAG1_BUF0I_MASK   (0x1U)
 
#define CAN_IFLAG1_BUF0I_SHIFT   (0U)
 
#define CAN_IFLAG1_BUF0I(x)   (((uint32_t)(((uint32_t)(x)) << CAN_IFLAG1_BUF0I_SHIFT)) & CAN_IFLAG1_BUF0I_MASK)
 
#define CAN_IFLAG1_BUF4TO1I_MASK   (0x1EU)
 
#define CAN_IFLAG1_BUF4TO1I_SHIFT   (1U)
 
#define CAN_IFLAG1_BUF4TO1I(x)   (((uint32_t)(((uint32_t)(x)) << CAN_IFLAG1_BUF4TO1I_SHIFT)) & CAN_IFLAG1_BUF4TO1I_MASK)
 
#define CAN_IFLAG1_BUF5I_MASK   (0x20U)
 
#define CAN_IFLAG1_BUF5I_SHIFT   (5U)
 
#define CAN_IFLAG1_BUF5I(x)   (((uint32_t)(((uint32_t)(x)) << CAN_IFLAG1_BUF5I_SHIFT)) & CAN_IFLAG1_BUF5I_MASK)
 
#define CAN_IFLAG1_BUF6I_MASK   (0x40U)
 
#define CAN_IFLAG1_BUF6I_SHIFT   (6U)
 
#define CAN_IFLAG1_BUF6I(x)   (((uint32_t)(((uint32_t)(x)) << CAN_IFLAG1_BUF6I_SHIFT)) & CAN_IFLAG1_BUF6I_MASK)
 
#define CAN_IFLAG1_BUF7I_MASK   (0x80U)
 
#define CAN_IFLAG1_BUF7I_SHIFT   (7U)
 
#define CAN_IFLAG1_BUF7I(x)   (((uint32_t)(((uint32_t)(x)) << CAN_IFLAG1_BUF7I_SHIFT)) & CAN_IFLAG1_BUF7I_MASK)
 
#define CAN_IFLAG1_BUF31TO8I_MASK   (0xFFFFFF00U)
 
#define CAN_IFLAG1_BUF31TO8I_SHIFT   (8U)
 
#define CAN_IFLAG1_BUF31TO8I(x)   (((uint32_t)(((uint32_t)(x)) << CAN_IFLAG1_BUF31TO8I_SHIFT)) & CAN_IFLAG1_BUF31TO8I_MASK)
 
CTRL2 - Control 2 register
#define CAN_CTRL2_EACEN_MASK   (0x10000U)
 
#define CAN_CTRL2_EACEN_SHIFT   (16U)
 
#define CAN_CTRL2_EACEN(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CTRL2_EACEN_SHIFT)) & CAN_CTRL2_EACEN_MASK)
 
#define CAN_CTRL2_RRS_MASK   (0x20000U)
 
#define CAN_CTRL2_RRS_SHIFT   (17U)
 
#define CAN_CTRL2_RRS(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CTRL2_RRS_SHIFT)) & CAN_CTRL2_RRS_MASK)
 
#define CAN_CTRL2_MRP_MASK   (0x40000U)
 
#define CAN_CTRL2_MRP_SHIFT   (18U)
 
#define CAN_CTRL2_MRP(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CTRL2_MRP_SHIFT)) & CAN_CTRL2_MRP_MASK)
 
#define CAN_CTRL2_TASD_MASK   (0xF80000U)
 
#define CAN_CTRL2_TASD_SHIFT   (19U)
 
#define CAN_CTRL2_TASD(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CTRL2_TASD_SHIFT)) & CAN_CTRL2_TASD_MASK)
 
#define CAN_CTRL2_RFFN_MASK   (0xF000000U)
 
#define CAN_CTRL2_RFFN_SHIFT   (24U)
 
#define CAN_CTRL2_RFFN(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CTRL2_RFFN_SHIFT)) & CAN_CTRL2_RFFN_MASK)
 
#define CAN_CTRL2_WRMFRZ_MASK   (0x10000000U)
 
#define CAN_CTRL2_WRMFRZ_SHIFT   (28U)
 
#define CAN_CTRL2_WRMFRZ(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CTRL2_WRMFRZ_SHIFT)) & CAN_CTRL2_WRMFRZ_MASK)
 
ESR2 - Error and Status 2 register
#define CAN_ESR2_IMB_MASK   (0x2000U)
 
#define CAN_ESR2_IMB_SHIFT   (13U)
 
#define CAN_ESR2_IMB(x)   (((uint32_t)(((uint32_t)(x)) << CAN_ESR2_IMB_SHIFT)) & CAN_ESR2_IMB_MASK)
 
#define CAN_ESR2_VPS_MASK   (0x4000U)
 
#define CAN_ESR2_VPS_SHIFT   (14U)
 
#define CAN_ESR2_VPS(x)   (((uint32_t)(((uint32_t)(x)) << CAN_ESR2_VPS_SHIFT)) & CAN_ESR2_VPS_MASK)
 
#define CAN_ESR2_LPTM_MASK   (0x7F0000U)
 
#define CAN_ESR2_LPTM_SHIFT   (16U)
 
#define CAN_ESR2_LPTM(x)   (((uint32_t)(((uint32_t)(x)) << CAN_ESR2_LPTM_SHIFT)) & CAN_ESR2_LPTM_MASK)
 
CRCR - CRC Register
#define CAN_CRCR_TXCRC_MASK   (0x7FFFU)
 
#define CAN_CRCR_TXCRC_SHIFT   (0U)
 
#define CAN_CRCR_TXCRC(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CRCR_TXCRC_SHIFT)) & CAN_CRCR_TXCRC_MASK)
 
#define CAN_CRCR_MBCRC_MASK   (0x7F0000U)
 
#define CAN_CRCR_MBCRC_SHIFT   (16U)
 
#define CAN_CRCR_MBCRC(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CRCR_MBCRC_SHIFT)) & CAN_CRCR_MBCRC_MASK)
 
RXFGMASK - Rx FIFO Global Mask register
#define CAN_RXFGMASK_FGM_MASK   (0xFFFFFFFFU)
 
#define CAN_RXFGMASK_FGM_SHIFT   (0U)
 
#define CAN_RXFGMASK_FGM(x)   (((uint32_t)(((uint32_t)(x)) << CAN_RXFGMASK_FGM_SHIFT)) & CAN_RXFGMASK_FGM_MASK)
 
RXFIR - Rx FIFO Information Register
#define CAN_RXFIR_IDHIT_MASK   (0x1FFU)
 
#define CAN_RXFIR_IDHIT_SHIFT   (0U)
 
#define CAN_RXFIR_IDHIT(x)   (((uint32_t)(((uint32_t)(x)) << CAN_RXFIR_IDHIT_SHIFT)) & CAN_RXFIR_IDHIT_MASK)
 
CS - Message Buffer 0 CS Register..Message Buffer 15 CS Register
#define CAN_CS_TIME_STAMP_MASK   (0xFFFFU)
 
#define CAN_CS_TIME_STAMP_SHIFT   (0U)
 
#define CAN_CS_TIME_STAMP(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CS_TIME_STAMP_SHIFT)) & CAN_CS_TIME_STAMP_MASK)
 
#define CAN_CS_DLC_MASK   (0xF0000U)
 
#define CAN_CS_DLC_SHIFT   (16U)
 
#define CAN_CS_DLC(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CS_DLC_SHIFT)) & CAN_CS_DLC_MASK)
 
#define CAN_CS_RTR_MASK   (0x100000U)
 
#define CAN_CS_RTR_SHIFT   (20U)
 
#define CAN_CS_RTR(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CS_RTR_SHIFT)) & CAN_CS_RTR_MASK)
 
#define CAN_CS_IDE_MASK   (0x200000U)
 
#define CAN_CS_IDE_SHIFT   (21U)
 
#define CAN_CS_IDE(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CS_IDE_SHIFT)) & CAN_CS_IDE_MASK)
 
#define CAN_CS_SRR_MASK   (0x400000U)
 
#define CAN_CS_SRR_SHIFT   (22U)
 
#define CAN_CS_SRR(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CS_SRR_SHIFT)) & CAN_CS_SRR_MASK)
 
#define CAN_CS_CODE_MASK   (0xF000000U)
 
#define CAN_CS_CODE_SHIFT   (24U)
 
#define CAN_CS_CODE(x)   (((uint32_t)(((uint32_t)(x)) << CAN_CS_CODE_SHIFT)) & CAN_CS_CODE_MASK)
 
#define CAN_CS_COUNT   (16U)
 
ID - Message Buffer 0 ID Register..Message Buffer 15 ID Register
#define CAN_ID_EXT_MASK   (0x3FFFFU)
 
#define CAN_ID_EXT_SHIFT   (0U)
 
#define CAN_ID_EXT(x)   (((uint32_t)(((uint32_t)(x)) << CAN_ID_EXT_SHIFT)) & CAN_ID_EXT_MASK)
 
#define CAN_ID_STD_MASK   (0x1FFC0000U)
 
#define CAN_ID_STD_SHIFT   (18U)
 
#define CAN_ID_STD(x)   (((uint32_t)(((uint32_t)(x)) << CAN_ID_STD_SHIFT)) & CAN_ID_STD_MASK)
 
#define CAN_ID_PRIO_MASK   (0xE0000000U)
 
#define CAN_ID_PRIO_SHIFT   (29U)
 
#define CAN_ID_PRIO(x)   (((uint32_t)(((uint32_t)(x)) << CAN_ID_PRIO_SHIFT)) & CAN_ID_PRIO_MASK)
 
#define CAN_ID_COUNT   (16U)
 
WORD0 - Message Buffer 0 WORD0 Register..Message Buffer 15 WORD0 Register
#define CAN_WORD0_DATA_BYTE_3_MASK   (0xFFU)
 
#define CAN_WORD0_DATA_BYTE_3_SHIFT   (0U)
 
#define CAN_WORD0_DATA_BYTE_3(x)   (((uint32_t)(((uint32_t)(x)) << CAN_WORD0_DATA_BYTE_3_SHIFT)) & CAN_WORD0_DATA_BYTE_3_MASK)
 
#define CAN_WORD0_DATA_BYTE_2_MASK   (0xFF00U)
 
#define CAN_WORD0_DATA_BYTE_2_SHIFT   (8U)
 
#define CAN_WORD0_DATA_BYTE_2(x)   (((uint32_t)(((uint32_t)(x)) << CAN_WORD0_DATA_BYTE_2_SHIFT)) & CAN_WORD0_DATA_BYTE_2_MASK)
 
#define CAN_WORD0_DATA_BYTE_1_MASK   (0xFF0000U)
 
#define CAN_WORD0_DATA_BYTE_1_SHIFT   (16U)
 
#define CAN_WORD0_DATA_BYTE_1(x)   (((uint32_t)(((uint32_t)(x)) << CAN_WORD0_DATA_BYTE_1_SHIFT)) & CAN_WORD0_DATA_BYTE_1_MASK)
 
#define CAN_WORD0_DATA_BYTE_0_MASK   (0xFF000000U)
 
#define CAN_WORD0_DATA_BYTE_0_SHIFT   (24U)
 
#define CAN_WORD0_DATA_BYTE_0(x)   (((uint32_t)(((uint32_t)(x)) << CAN_WORD0_DATA_BYTE_0_SHIFT)) & CAN_WORD0_DATA_BYTE_0_MASK)
 
#define CAN_WORD0_COUNT   (16U)
 
WORD1 - Message Buffer 0 WORD1 Register..Message Buffer 15 WORD1 Register
#define CAN_WORD1_DATA_BYTE_7_MASK   (0xFFU)
 
#define CAN_WORD1_DATA_BYTE_7_SHIFT   (0U)
 
#define CAN_WORD1_DATA_BYTE_7(x)   (((uint32_t)(((uint32_t)(x)) << CAN_WORD1_DATA_BYTE_7_SHIFT)) & CAN_WORD1_DATA_BYTE_7_MASK)
 
#define CAN_WORD1_DATA_BYTE_6_MASK   (0xFF00U)
 
#define CAN_WORD1_DATA_BYTE_6_SHIFT   (8U)
 
#define CAN_WORD1_DATA_BYTE_6(x)   (((uint32_t)(((uint32_t)(x)) << CAN_WORD1_DATA_BYTE_6_SHIFT)) & CAN_WORD1_DATA_BYTE_6_MASK)
 
#define CAN_WORD1_DATA_BYTE_5_MASK   (0xFF0000U)
 
#define CAN_WORD1_DATA_BYTE_5_SHIFT   (16U)
 
#define CAN_WORD1_DATA_BYTE_5(x)   (((uint32_t)(((uint32_t)(x)) << CAN_WORD1_DATA_BYTE_5_SHIFT)) & CAN_WORD1_DATA_BYTE_5_MASK)
 
#define CAN_WORD1_DATA_BYTE_4_MASK   (0xFF000000U)
 
#define CAN_WORD1_DATA_BYTE_4_SHIFT   (24U)
 
#define CAN_WORD1_DATA_BYTE_4(x)   (((uint32_t)(((uint32_t)(x)) << CAN_WORD1_DATA_BYTE_4_SHIFT)) & CAN_WORD1_DATA_BYTE_4_MASK)
 
#define CAN_WORD1_COUNT   (16U)
 
RXIMR - Rx Individual Mask Registers
#define CAN_RXIMR_MI_MASK   (0xFFFFFFFFU)
 
#define CAN_RXIMR_MI_SHIFT   (0U)
 
#define CAN_RXIMR_MI(x)   (((uint32_t)(((uint32_t)(x)) << CAN_RXIMR_MI_SHIFT)) & CAN_RXIMR_MI_MASK)
 
#define CAN_RXIMR_COUNT   (16U)
 
DIRECT - Direct access register 0..Direct access register 15
#define CAU_DIRECT_CAU_DIRECT0_MASK   (0xFFFFFFFFU)
 
#define CAU_DIRECT_CAU_DIRECT0_SHIFT   (0U)
 
#define CAU_DIRECT_CAU_DIRECT0(x)   (((uint32_t)(((uint32_t)(x)) << CAU_DIRECT_CAU_DIRECT0_SHIFT)) & CAU_DIRECT_CAU_DIRECT0_MASK)
 
#define CAU_DIRECT_CAU_DIRECT1_MASK   (0xFFFFFFFFU)
 
#define CAU_DIRECT_CAU_DIRECT1_SHIFT   (0U)
 
#define CAU_DIRECT_CAU_DIRECT1(x)   (((uint32_t)(((uint32_t)(x)) << CAU_DIRECT_CAU_DIRECT1_SHIFT)) & CAU_DIRECT_CAU_DIRECT1_MASK)
 
#define CAU_DIRECT_CAU_DIRECT2_MASK   (0xFFFFFFFFU)
 
#define CAU_DIRECT_CAU_DIRECT2_SHIFT   (0U)
 
#define CAU_DIRECT_CAU_DIRECT2(x)   (((uint32_t)(((uint32_t)(x)) << CAU_DIRECT_CAU_DIRECT2_SHIFT)) & CAU_DIRECT_CAU_DIRECT2_MASK)
 
#define CAU_DIRECT_CAU_DIRECT3_MASK   (0xFFFFFFFFU)
 
#define CAU_DIRECT_CAU_DIRECT3_SHIFT   (0U)
 
#define CAU_DIRECT_CAU_DIRECT3(x)   (((uint32_t)(((uint32_t)(x)) << CAU_DIRECT_CAU_DIRECT3_SHIFT)) & CAU_DIRECT_CAU_DIRECT3_MASK)
 
#define CAU_DIRECT_CAU_DIRECT4_MASK   (0xFFFFFFFFU)
 
#define CAU_DIRECT_CAU_DIRECT4_SHIFT   (0U)
 
#define CAU_DIRECT_CAU_DIRECT4(x)   (((uint32_t)(((uint32_t)(x)) << CAU_DIRECT_CAU_DIRECT4_SHIFT)) & CAU_DIRECT_CAU_DIRECT4_MASK)
 
#define CAU_DIRECT_CAU_DIRECT5_MASK   (0xFFFFFFFFU)
 
#define CAU_DIRECT_CAU_DIRECT5_SHIFT   (0U)
 
#define CAU_DIRECT_CAU_DIRECT5(x)   (((uint32_t)(((uint32_t)(x)) << CAU_DIRECT_CAU_DIRECT5_SHIFT)) & CAU_DIRECT_CAU_DIRECT5_MASK)
 
#define CAU_DIRECT_CAU_DIRECT6_MASK   (0xFFFFFFFFU)
 
#define CAU_DIRECT_CAU_DIRECT6_SHIFT   (0U)
 
#define CAU_DIRECT_CAU_DIRECT6(x)   (((uint32_t)(((uint32_t)(x)) << CAU_DIRECT_CAU_DIRECT6_SHIFT)) & CAU_DIRECT_CAU_DIRECT6_MASK)
 
#define CAU_DIRECT_CAU_DIRECT7_MASK   (0xFFFFFFFFU)
 
#define CAU_DIRECT_CAU_DIRECT7_SHIFT   (0U)
 
#define CAU_DIRECT_CAU_DIRECT7(x)   (((uint32_t)(((uint32_t)(x)) << CAU_DIRECT_CAU_DIRECT7_SHIFT)) & CAU_DIRECT_CAU_DIRECT7_MASK)
 
#define CAU_DIRECT_CAU_DIRECT8_MASK   (0xFFFFFFFFU)
 
#define CAU_DIRECT_CAU_DIRECT8_SHIFT   (0U)
 
#define CAU_DIRECT_CAU_DIRECT8(x)   (((uint32_t)(((uint32_t)(x)) << CAU_DIRECT_CAU_DIRECT8_SHIFT)) & CAU_DIRECT_CAU_DIRECT8_MASK)
 
#define CAU_DIRECT_CAU_DIRECT9_MASK   (0xFFFFFFFFU)
 
#define CAU_DIRECT_CAU_DIRECT9_SHIFT   (0U)
 
#define CAU_DIRECT_CAU_DIRECT9(x)   (((uint32_t)(((uint32_t)(x)) << CAU_DIRECT_CAU_DIRECT9_SHIFT)) & CAU_DIRECT_CAU_DIRECT9_MASK)
 
#define CAU_DIRECT_CAU_DIRECT10_MASK   (0xFFFFFFFFU)
 
#define CAU_DIRECT_CAU_DIRECT10_SHIFT   (0U)
 
#define CAU_DIRECT_CAU_DIRECT10(x)   (((uint32_t)(((uint32_t)(x)) << CAU_DIRECT_CAU_DIRECT10_SHIFT)) & CAU_DIRECT_CAU_DIRECT10_MASK)
 
#define CAU_DIRECT_CAU_DIRECT11_MASK   (0xFFFFFFFFU)
 
#define CAU_DIRECT_CAU_DIRECT11_SHIFT   (0U)
 
#define CAU_DIRECT_CAU_DIRECT11(x)   (((uint32_t)(((uint32_t)(x)) << CAU_DIRECT_CAU_DIRECT11_SHIFT)) & CAU_DIRECT_CAU_DIRECT11_MASK)
 
#define CAU_DIRECT_CAU_DIRECT12_MASK   (0xFFFFFFFFU)
 
#define CAU_DIRECT_CAU_DIRECT12_SHIFT   (0U)
 
#define CAU_DIRECT_CAU_DIRECT12(x)   (((uint32_t)(((uint32_t)(x)) << CAU_DIRECT_CAU_DIRECT12_SHIFT)) & CAU_DIRECT_CAU_DIRECT12_MASK)
 
#define CAU_DIRECT_CAU_DIRECT13_MASK   (0xFFFFFFFFU)
 
#define CAU_DIRECT_CAU_DIRECT13_SHIFT   (0U)
 
#define CAU_DIRECT_CAU_DIRECT13(x)   (((uint32_t)(((uint32_t)(x)) << CAU_DIRECT_CAU_DIRECT13_SHIFT)) & CAU_DIRECT_CAU_DIRECT13_MASK)
 
#define CAU_DIRECT_CAU_DIRECT14_MASK   (0xFFFFFFFFU)
 
#define CAU_DIRECT_CAU_DIRECT14_SHIFT   (0U)
 
#define CAU_DIRECT_CAU_DIRECT14(x)   (((uint32_t)(((uint32_t)(x)) << CAU_DIRECT_CAU_DIRECT14_SHIFT)) & CAU_DIRECT_CAU_DIRECT14_MASK)
 
#define CAU_DIRECT_CAU_DIRECT15_MASK   (0xFFFFFFFFU)
 
#define CAU_DIRECT_CAU_DIRECT15_SHIFT   (0U)
 
#define CAU_DIRECT_CAU_DIRECT15(x)   (((uint32_t)(((uint32_t)(x)) << CAU_DIRECT_CAU_DIRECT15_SHIFT)) & CAU_DIRECT_CAU_DIRECT15_MASK)
 
#define CAU_DIRECT_COUNT   (16U)
 
LDR_CASR - Status register - Load Register command
#define CAU_LDR_CASR_IC_MASK   (0x1U)
 
#define CAU_LDR_CASR_IC_SHIFT   (0U)
 
#define CAU_LDR_CASR_IC(x)   (((uint32_t)(((uint32_t)(x)) << CAU_LDR_CASR_IC_SHIFT)) & CAU_LDR_CASR_IC_MASK)
 
#define CAU_LDR_CASR_DPE_MASK   (0x2U)
 
#define CAU_LDR_CASR_DPE_SHIFT   (1U)
 
#define CAU_LDR_CASR_DPE(x)   (((uint32_t)(((uint32_t)(x)) << CAU_LDR_CASR_DPE_SHIFT)) & CAU_LDR_CASR_DPE_MASK)
 
#define CAU_LDR_CASR_VER_MASK   (0xF0000000U)
 
#define CAU_LDR_CASR_VER_SHIFT   (28U)
 
#define CAU_LDR_CASR_VER(x)   (((uint32_t)(((uint32_t)(x)) << CAU_LDR_CASR_VER_SHIFT)) & CAU_LDR_CASR_VER_MASK)
 
LDR_CAA - Accumulator register - Load Register command
#define CAU_LDR_CAA_ACC_MASK   (0xFFFFFFFFU)
 
#define CAU_LDR_CAA_ACC_SHIFT   (0U)
 
#define CAU_LDR_CAA_ACC(x)   (((uint32_t)(((uint32_t)(x)) << CAU_LDR_CAA_ACC_SHIFT)) & CAU_LDR_CAA_ACC_MASK)
 
LDR_CA - General Purpose Register 0 - Load Register command..General Purpose Register 8 - Load Register command
#define CAU_LDR_CA_CA0_MASK   (0xFFFFFFFFU)
 
#define CAU_LDR_CA_CA0_SHIFT   (0U)
 
#define CAU_LDR_CA_CA0(x)   (((uint32_t)(((uint32_t)(x)) << CAU_LDR_CA_CA0_SHIFT)) & CAU_LDR_CA_CA0_MASK)
 
#define CAU_LDR_CA_CA1_MASK   (0xFFFFFFFFU)
 
#define CAU_LDR_CA_CA1_SHIFT   (0U)
 
#define CAU_LDR_CA_CA1(x)   (((uint32_t)(((uint32_t)(x)) << CAU_LDR_CA_CA1_SHIFT)) & CAU_LDR_CA_CA1_MASK)
 
#define CAU_LDR_CA_CA2_MASK   (0xFFFFFFFFU)
 
#define CAU_LDR_CA_CA2_SHIFT   (0U)
 
#define CAU_LDR_CA_CA2(x)   (((uint32_t)(((uint32_t)(x)) << CAU_LDR_CA_CA2_SHIFT)) & CAU_LDR_CA_CA2_MASK)
 
#define CAU_LDR_CA_CA3_MASK   (0xFFFFFFFFU)
 
#define CAU_LDR_CA_CA3_SHIFT   (0U)
 
#define CAU_LDR_CA_CA3(x)   (((uint32_t)(((uint32_t)(x)) << CAU_LDR_CA_CA3_SHIFT)) & CAU_LDR_CA_CA3_MASK)
 
#define CAU_LDR_CA_CA4_MASK   (0xFFFFFFFFU)
 
#define CAU_LDR_CA_CA4_SHIFT   (0U)
 
#define CAU_LDR_CA_CA4(x)   (((uint32_t)(((uint32_t)(x)) << CAU_LDR_CA_CA4_SHIFT)) & CAU_LDR_CA_CA4_MASK)
 
#define CAU_LDR_CA_CA5_MASK   (0xFFFFFFFFU)
 
#define CAU_LDR_CA_CA5_SHIFT   (0U)
 
#define CAU_LDR_CA_CA5(x)   (((uint32_t)(((uint32_t)(x)) << CAU_LDR_CA_CA5_SHIFT)) & CAU_LDR_CA_CA5_MASK)
 
#define CAU_LDR_CA_CA6_MASK   (0xFFFFFFFFU)
 
#define CAU_LDR_CA_CA6_SHIFT   (0U)
 
#define CAU_LDR_CA_CA6(x)   (((uint32_t)(((uint32_t)(x)) << CAU_LDR_CA_CA6_SHIFT)) & CAU_LDR_CA_CA6_MASK)
 
#define CAU_LDR_CA_CA7_MASK   (0xFFFFFFFFU)
 
#define CAU_LDR_CA_CA7_SHIFT   (0U)
 
#define CAU_LDR_CA_CA7(x)   (((uint32_t)(((uint32_t)(x)) << CAU_LDR_CA_CA7_SHIFT)) & CAU_LDR_CA_CA7_MASK)
 
#define CAU_LDR_CA_CA8_MASK   (0xFFFFFFFFU)
 
#define CAU_LDR_CA_CA8_SHIFT   (0U)
 
#define CAU_LDR_CA_CA8(x)   (((uint32_t)(((uint32_t)(x)) << CAU_LDR_CA_CA8_SHIFT)) & CAU_LDR_CA_CA8_MASK)
 
#define CAU_LDR_CA_COUNT   (9U)
 
STR_CASR - Status register - Store Register command
#define CAU_STR_CASR_IC_MASK   (0x1U)
 
#define CAU_STR_CASR_IC_SHIFT   (0U)
 
#define CAU_STR_CASR_IC(x)   (((uint32_t)(((uint32_t)(x)) << CAU_STR_CASR_IC_SHIFT)) & CAU_STR_CASR_IC_MASK)
 
#define CAU_STR_CASR_DPE_MASK   (0x2U)
 
#define CAU_STR_CASR_DPE_SHIFT   (1U)
 
#define CAU_STR_CASR_DPE(x)   (((uint32_t)(((uint32_t)(x)) << CAU_STR_CASR_DPE_SHIFT)) & CAU_STR_CASR_DPE_MASK)
 
#define CAU_STR_CASR_VER_MASK   (0xF0000000U)
 
#define CAU_STR_CASR_VER_SHIFT   (28U)
 
#define CAU_STR_CASR_VER(x)   (((uint32_t)(((uint32_t)(x)) << CAU_STR_CASR_VER_SHIFT)) & CAU_STR_CASR_VER_MASK)
 
STR_CAA - Accumulator register - Store Register command
#define CAU_STR_CAA_ACC_MASK   (0xFFFFFFFFU)
 
#define CAU_STR_CAA_ACC_SHIFT   (0U)
 
#define CAU_STR_CAA_ACC(x)   (((uint32_t)(((uint32_t)(x)) << CAU_STR_CAA_ACC_SHIFT)) & CAU_STR_CAA_ACC_MASK)
 
STR_CA - General Purpose Register 0 - Store Register command..General Purpose Register 8 - Store Register command
#define CAU_STR_CA_CA0_MASK   (0xFFFFFFFFU)
 
#define CAU_STR_CA_CA0_SHIFT   (0U)
 
#define CAU_STR_CA_CA0(x)   (((uint32_t)(((uint32_t)(x)) << CAU_STR_CA_CA0_SHIFT)) & CAU_STR_CA_CA0_MASK)
 
#define CAU_STR_CA_CA1_MASK   (0xFFFFFFFFU)
 
#define CAU_STR_CA_CA1_SHIFT   (0U)
 
#define CAU_STR_CA_CA1(x)   (((uint32_t)(((uint32_t)(x)) << CAU_STR_CA_CA1_SHIFT)) & CAU_STR_CA_CA1_MASK)
 
#define CAU_STR_CA_CA2_MASK   (0xFFFFFFFFU)
 
#define CAU_STR_CA_CA2_SHIFT   (0U)
 
#define CAU_STR_CA_CA2(x)   (((uint32_t)(((uint32_t)(x)) << CAU_STR_CA_CA2_SHIFT)) & CAU_STR_CA_CA2_MASK)
 
#define CAU_STR_CA_CA3_MASK   (0xFFFFFFFFU)
 
#define CAU_STR_CA_CA3_SHIFT   (0U)
 
#define CAU_STR_CA_CA3(x)   (((uint32_t)(((uint32_t)(x)) << CAU_STR_CA_CA3_SHIFT)) & CAU_STR_CA_CA3_MASK)
 
#define CAU_STR_CA_CA4_MASK   (0xFFFFFFFFU)
 
#define CAU_STR_CA_CA4_SHIFT   (0U)
 
#define CAU_STR_CA_CA4(x)   (((uint32_t)(((uint32_t)(x)) << CAU_STR_CA_CA4_SHIFT)) & CAU_STR_CA_CA4_MASK)
 
#define CAU_STR_CA_CA5_MASK   (0xFFFFFFFFU)
 
#define CAU_STR_CA_CA5_SHIFT   (0U)
 
#define CAU_STR_CA_CA5(x)   (((uint32_t)(((uint32_t)(x)) << CAU_STR_CA_CA5_SHIFT)) & CAU_STR_CA_CA5_MASK)
 
#define CAU_STR_CA_CA6_MASK   (0xFFFFFFFFU)
 
#define CAU_STR_CA_CA6_SHIFT   (0U)
 
#define CAU_STR_CA_CA6(x)   (((uint32_t)(((uint32_t)(x)) << CAU_STR_CA_CA6_SHIFT)) & CAU_STR_CA_CA6_MASK)
 
#define CAU_STR_CA_CA7_MASK   (0xFFFFFFFFU)
 
#define CAU_STR_CA_CA7_SHIFT   (0U)
 
#define CAU_STR_CA_CA7(x)   (((uint32_t)(((uint32_t)(x)) << CAU_STR_CA_CA7_SHIFT)) & CAU_STR_CA_CA7_MASK)
 
#define CAU_STR_CA_CA8_MASK   (0xFFFFFFFFU)
 
#define CAU_STR_CA_CA8_SHIFT   (0U)
 
#define CAU_STR_CA_CA8(x)   (((uint32_t)(((uint32_t)(x)) << CAU_STR_CA_CA8_SHIFT)) & CAU_STR_CA_CA8_MASK)
 
#define CAU_STR_CA_COUNT   (9U)
 
ADR_CASR - Status register - Add Register command
#define CAU_ADR_CASR_IC_MASK   (0x1U)
 
#define CAU_ADR_CASR_IC_SHIFT   (0U)
 
#define CAU_ADR_CASR_IC(x)   (((uint32_t)(((uint32_t)(x)) << CAU_ADR_CASR_IC_SHIFT)) & CAU_ADR_CASR_IC_MASK)
 
#define CAU_ADR_CASR_DPE_MASK   (0x2U)
 
#define CAU_ADR_CASR_DPE_SHIFT   (1U)
 
#define CAU_ADR_CASR_DPE(x)   (((uint32_t)(((uint32_t)(x)) << CAU_ADR_CASR_DPE_SHIFT)) & CAU_ADR_CASR_DPE_MASK)
 
#define CAU_ADR_CASR_VER_MASK   (0xF0000000U)
 
#define CAU_ADR_CASR_VER_SHIFT   (28U)
 
#define CAU_ADR_CASR_VER(x)   (((uint32_t)(((uint32_t)(x)) << CAU_ADR_CASR_VER_SHIFT)) & CAU_ADR_CASR_VER_MASK)
 
ADR_CAA - Accumulator register - Add to register command
#define CAU_ADR_CAA_ACC_MASK   (0xFFFFFFFFU)
 
#define CAU_ADR_CAA_ACC_SHIFT   (0U)
 
#define CAU_ADR_CAA_ACC(x)   (((uint32_t)(((uint32_t)(x)) << CAU_ADR_CAA_ACC_SHIFT)) & CAU_ADR_CAA_ACC_MASK)
 
ADR_CA - General Purpose Register 0 - Add to register command..General Purpose Register 8 - Add to register command
#define CAU_ADR_CA_CA0_MASK   (0xFFFFFFFFU)
 
#define CAU_ADR_CA_CA0_SHIFT   (0U)
 
#define CAU_ADR_CA_CA0(x)   (((uint32_t)(((uint32_t)(x)) << CAU_ADR_CA_CA0_SHIFT)) & CAU_ADR_CA_CA0_MASK)
 
#define CAU_ADR_CA_CA1_MASK   (0xFFFFFFFFU)
 
#define CAU_ADR_CA_CA1_SHIFT   (0U)
 
#define CAU_ADR_CA_CA1(x)   (((uint32_t)(((uint32_t)(x)) << CAU_ADR_CA_CA1_SHIFT)) & CAU_ADR_CA_CA1_MASK)
 
#define CAU_ADR_CA_CA2_MASK   (0xFFFFFFFFU)
 
#define CAU_ADR_CA_CA2_SHIFT   (0U)
 
#define CAU_ADR_CA_CA2(x)   (((uint32_t)(((uint32_t)(x)) << CAU_ADR_CA_CA2_SHIFT)) & CAU_ADR_CA_CA2_MASK)
 
#define CAU_ADR_CA_CA3_MASK   (0xFFFFFFFFU)
 
#define CAU_ADR_CA_CA3_SHIFT   (0U)
 
#define CAU_ADR_CA_CA3(x)   (((uint32_t)(((uint32_t)(x)) << CAU_ADR_CA_CA3_SHIFT)) & CAU_ADR_CA_CA3_MASK)
 
#define CAU_ADR_CA_CA4_MASK   (0xFFFFFFFFU)
 
#define CAU_ADR_CA_CA4_SHIFT   (0U)
 
#define CAU_ADR_CA_CA4(x)   (((uint32_t)(((uint32_t)(x)) << CAU_ADR_CA_CA4_SHIFT)) & CAU_ADR_CA_CA4_MASK)
 
#define CAU_ADR_CA_CA5_MASK   (0xFFFFFFFFU)
 
#define CAU_ADR_CA_CA5_SHIFT   (0U)
 
#define CAU_ADR_CA_CA5(x)   (((uint32_t)(((uint32_t)(x)) << CAU_ADR_CA_CA5_SHIFT)) & CAU_ADR_CA_CA5_MASK)
 
#define CAU_ADR_CA_CA6_MASK   (0xFFFFFFFFU)
 
#define CAU_ADR_CA_CA6_SHIFT   (0U)
 
#define CAU_ADR_CA_CA6(x)   (((uint32_t)(((uint32_t)(x)) << CAU_ADR_CA_CA6_SHIFT)) & CAU_ADR_CA_CA6_MASK)
 
#define CAU_ADR_CA_CA7_MASK   (0xFFFFFFFFU)
 
#define CAU_ADR_CA_CA7_SHIFT   (0U)
 
#define CAU_ADR_CA_CA7(x)   (((uint32_t)(((uint32_t)(x)) << CAU_ADR_CA_CA7_SHIFT)) & CAU_ADR_CA_CA7_MASK)
 
#define CAU_ADR_CA_CA8_MASK   (0xFFFFFFFFU)
 
#define CAU_ADR_CA_CA8_SHIFT   (0U)
 
#define CAU_ADR_CA_CA8(x)   (((uint32_t)(((uint32_t)(x)) << CAU_ADR_CA_CA8_SHIFT)) & CAU_ADR_CA_CA8_MASK)
 
#define CAU_ADR_CA_COUNT   (9U)
 
RADR_CASR - Status register - Reverse and Add to Register command
#define CAU_RADR_CASR_IC_MASK   (0x1U)
 
#define CAU_RADR_CASR_IC_SHIFT   (0U)
 
#define CAU_RADR_CASR_IC(x)   (((uint32_t)(((uint32_t)(x)) << CAU_RADR_CASR_IC_SHIFT)) & CAU_RADR_CASR_IC_MASK)
 
#define CAU_RADR_CASR_DPE_MASK   (0x2U)
 
#define CAU_RADR_CASR_DPE_SHIFT   (1U)
 
#define CAU_RADR_CASR_DPE(x)   (((uint32_t)(((uint32_t)(x)) << CAU_RADR_CASR_DPE_SHIFT)) & CAU_RADR_CASR_DPE_MASK)
 
#define CAU_RADR_CASR_VER_MASK   (0xF0000000U)
 
#define CAU_RADR_CASR_VER_SHIFT   (28U)
 
#define CAU_RADR_CASR_VER(x)   (((uint32_t)(((uint32_t)(x)) << CAU_RADR_CASR_VER_SHIFT)) & CAU_RADR_CASR_VER_MASK)
 
RADR_CAA - Accumulator register - Reverse and Add to Register command
#define CAU_RADR_CAA_ACC_MASK   (0xFFFFFFFFU)
 
#define CAU_RADR_CAA_ACC_SHIFT   (0U)
 
#define CAU_RADR_CAA_ACC(x)   (((uint32_t)(((uint32_t)(x)) << CAU_RADR_CAA_ACC_SHIFT)) & CAU_RADR_CAA_ACC_MASK)
 
RADR_CA - General Purpose Register 0 - Reverse and Add to Register command..General Purpose Register 8 - Reverse and Add to Register command
#define CAU_RADR_CA_CA0_MASK   (0xFFFFFFFFU)
 
#define CAU_RADR_CA_CA0_SHIFT   (0U)
 
#define CAU_RADR_CA_CA0(x)   (((uint32_t)(((uint32_t)(x)) << CAU_RADR_CA_CA0_SHIFT)) & CAU_RADR_CA_CA0_MASK)
 
#define CAU_RADR_CA_CA1_MASK   (0xFFFFFFFFU)
 
#define CAU_RADR_CA_CA1_SHIFT   (0U)
 
#define CAU_RADR_CA_CA1(x)   (((uint32_t)(((uint32_t)(x)) << CAU_RADR_CA_CA1_SHIFT)) & CAU_RADR_CA_CA1_MASK)
 
#define CAU_RADR_CA_CA2_MASK   (0xFFFFFFFFU)
 
#define CAU_RADR_CA_CA2_SHIFT   (0U)
 
#define CAU_RADR_CA_CA2(x)   (((uint32_t)(((uint32_t)(x)) << CAU_RADR_CA_CA2_SHIFT)) & CAU_RADR_CA_CA2_MASK)
 
#define CAU_RADR_CA_CA3_MASK   (0xFFFFFFFFU)
 
#define CAU_RADR_CA_CA3_SHIFT   (0U)
 
#define CAU_RADR_CA_CA3(x)   (((uint32_t)(((uint32_t)(x)) << CAU_RADR_CA_CA3_SHIFT)) & CAU_RADR_CA_CA3_MASK)
 
#define CAU_RADR_CA_CA4_MASK   (0xFFFFFFFFU)
 
#define CAU_RADR_CA_CA4_SHIFT   (0U)
 
#define CAU_RADR_CA_CA4(x)   (((uint32_t)(((uint32_t)(x)) << CAU_RADR_CA_CA4_SHIFT)) & CAU_RADR_CA_CA4_MASK)
 
#define CAU_RADR_CA_CA5_MASK   (0xFFFFFFFFU)
 
#define CAU_RADR_CA_CA5_SHIFT   (0U)
 
#define CAU_RADR_CA_CA5(x)   (((uint32_t)(((uint32_t)(x)) << CAU_RADR_CA_CA5_SHIFT)) & CAU_RADR_CA_CA5_MASK)
 
#define CAU_RADR_CA_CA6_MASK   (0xFFFFFFFFU)
 
#define CAU_RADR_CA_CA6_SHIFT   (0U)
 
#define CAU_RADR_CA_CA6(x)   (((uint32_t)(((uint32_t)(x)) << CAU_RADR_CA_CA6_SHIFT)) & CAU_RADR_CA_CA6_MASK)
 
#define CAU_RADR_CA_CA7_MASK   (0xFFFFFFFFU)
 
#define CAU_RADR_CA_CA7_SHIFT   (0U)
 
#define CAU_RADR_CA_CA7(x)   (((uint32_t)(((uint32_t)(x)) << CAU_RADR_CA_CA7_SHIFT)) & CAU_RADR_CA_CA7_MASK)
 
#define CAU_RADR_CA_CA8_MASK   (0xFFFFFFFFU)
 
#define CAU_RADR_CA_CA8_SHIFT   (0U)
 
#define CAU_RADR_CA_CA8(x)   (((uint32_t)(((uint32_t)(x)) << CAU_RADR_CA_CA8_SHIFT)) & CAU_RADR_CA_CA8_MASK)
 
#define CAU_RADR_CA_COUNT   (9U)
 
XOR_CASR - Status register - Exclusive Or command
#define CAU_XOR_CASR_IC_MASK   (0x1U)
 
#define CAU_XOR_CASR_IC_SHIFT   (0U)
 
#define CAU_XOR_CASR_IC(x)   (((uint32_t)(((uint32_t)(x)) << CAU_XOR_CASR_IC_SHIFT)) & CAU_XOR_CASR_IC_MASK)
 
#define CAU_XOR_CASR_DPE_MASK   (0x2U)
 
#define CAU_XOR_CASR_DPE_SHIFT   (1U)
 
#define CAU_XOR_CASR_DPE(x)   (((uint32_t)(((uint32_t)(x)) << CAU_XOR_CASR_DPE_SHIFT)) & CAU_XOR_CASR_DPE_MASK)
 
#define CAU_XOR_CASR_VER_MASK   (0xF0000000U)
 
#define CAU_XOR_CASR_VER_SHIFT   (28U)
 
#define CAU_XOR_CASR_VER(x)   (((uint32_t)(((uint32_t)(x)) << CAU_XOR_CASR_VER_SHIFT)) & CAU_XOR_CASR_VER_MASK)
 
XOR_CAA - Accumulator register - Exclusive Or command
#define CAU_XOR_CAA_ACC_MASK   (0xFFFFFFFFU)
 
#define CAU_XOR_CAA_ACC_SHIFT   (0U)
 
#define CAU_XOR_CAA_ACC(x)   (((uint32_t)(((uint32_t)(x)) << CAU_XOR_CAA_ACC_SHIFT)) & CAU_XOR_CAA_ACC_MASK)
 
XOR_CA - General Purpose Register 0 - Exclusive Or command..General Purpose Register 8 - Exclusive Or command
#define CAU_XOR_CA_CA0_MASK   (0xFFFFFFFFU)
 
#define CAU_XOR_CA_CA0_SHIFT   (0U)
 
#define CAU_XOR_CA_CA0(x)   (((uint32_t)(((uint32_t)(x)) << CAU_XOR_CA_CA0_SHIFT)) & CAU_XOR_CA_CA0_MASK)
 
#define CAU_XOR_CA_CA1_MASK   (0xFFFFFFFFU)
 
#define CAU_XOR_CA_CA1_SHIFT   (0U)
 
#define CAU_XOR_CA_CA1(x)   (((uint32_t)(((uint32_t)(x)) << CAU_XOR_CA_CA1_SHIFT)) & CAU_XOR_CA_CA1_MASK)
 
#define CAU_XOR_CA_CA2_MASK   (0xFFFFFFFFU)
 
#define CAU_XOR_CA_CA2_SHIFT   (0U)
 
#define CAU_XOR_CA_CA2(x)   (((uint32_t)(((uint32_t)(x)) << CAU_XOR_CA_CA2_SHIFT)) & CAU_XOR_CA_CA2_MASK)
 
#define CAU_XOR_CA_CA3_MASK   (0xFFFFFFFFU)
 
#define CAU_XOR_CA_CA3_SHIFT   (0U)
 
#define CAU_XOR_CA_CA3(x)   (((uint32_t)(((uint32_t)(x)) << CAU_XOR_CA_CA3_SHIFT)) & CAU_XOR_CA_CA3_MASK)
 
#define CAU_XOR_CA_CA4_MASK   (0xFFFFFFFFU)
 
#define CAU_XOR_CA_CA4_SHIFT   (0U)
 
#define CAU_XOR_CA_CA4(x)   (((uint32_t)(((uint32_t)(x)) << CAU_XOR_CA_CA4_SHIFT)) & CAU_XOR_CA_CA4_MASK)
 
#define CAU_XOR_CA_CA5_MASK   (0xFFFFFFFFU)
 
#define CAU_XOR_CA_CA5_SHIFT   (0U)
 
#define CAU_XOR_CA_CA5(x)   (((uint32_t)(((uint32_t)(x)) << CAU_XOR_CA_CA5_SHIFT)) & CAU_XOR_CA_CA5_MASK)
 
#define CAU_XOR_CA_CA6_MASK   (0xFFFFFFFFU)
 
#define CAU_XOR_CA_CA6_SHIFT   (0U)
 
#define CAU_XOR_CA_CA6(x)   (((uint32_t)(((uint32_t)(x)) << CAU_XOR_CA_CA6_SHIFT)) & CAU_XOR_CA_CA6_MASK)
 
#define CAU_XOR_CA_CA7_MASK   (0xFFFFFFFFU)
 
#define CAU_XOR_CA_CA7_SHIFT   (0U)
 
#define CAU_XOR_CA_CA7(x)   (((uint32_t)(((uint32_t)(x)) << CAU_XOR_CA_CA7_SHIFT)) & CAU_XOR_CA_CA7_MASK)
 
#define CAU_XOR_CA_CA8_MASK   (0xFFFFFFFFU)
 
#define CAU_XOR_CA_CA8_SHIFT   (0U)
 
#define CAU_XOR_CA_CA8(x)   (((uint32_t)(((uint32_t)(x)) << CAU_XOR_CA_CA8_SHIFT)) & CAU_XOR_CA_CA8_MASK)
 
#define CAU_XOR_CA_COUNT   (9U)
 
ROTL_CASR - Status register - Rotate Left command
#define CAU_ROTL_CASR_IC_MASK   (0x1U)
 
#define CAU_ROTL_CASR_IC_SHIFT   (0U)
 
#define CAU_ROTL_CASR_IC(x)   (((uint32_t)(((uint32_t)(x)) << CAU_ROTL_CASR_IC_SHIFT)) & CAU_ROTL_CASR_IC_MASK)
 
#define CAU_ROTL_CASR_DPE_MASK   (0x2U)
 
#define CAU_ROTL_CASR_DPE_SHIFT   (1U)
 
#define CAU_ROTL_CASR_DPE(x)   (((uint32_t)(((uint32_t)(x)) << CAU_ROTL_CASR_DPE_SHIFT)) & CAU_ROTL_CASR_DPE_MASK)
 
#define CAU_ROTL_CASR_VER_MASK   (0xF0000000U)
 
#define CAU_ROTL_CASR_VER_SHIFT   (28U)
 
#define CAU_ROTL_CASR_VER(x)   (((uint32_t)(((uint32_t)(x)) << CAU_ROTL_CASR_VER_SHIFT)) & CAU_ROTL_CASR_VER_MASK)
 
ROTL_CAA - Accumulator register - Rotate Left command
#define CAU_ROTL_CAA_ACC_MASK   (0xFFFFFFFFU)
 
#define CAU_ROTL_CAA_ACC_SHIFT   (0U)
 
#define CAU_ROTL_CAA_ACC(x)   (((uint32_t)(((uint32_t)(x)) << CAU_ROTL_CAA_ACC_SHIFT)) & CAU_ROTL_CAA_ACC_MASK)
 
ROTL_CA - General Purpose Register 0 - Rotate Left command..General Purpose Register 8 - Rotate Left command
#define CAU_ROTL_CA_CA0_MASK   (0xFFFFFFFFU)
 
#define CAU_ROTL_CA_CA0_SHIFT   (0U)
 
#define CAU_ROTL_CA_CA0(x)   (((uint32_t)(((uint32_t)(x)) << CAU_ROTL_CA_CA0_SHIFT)) & CAU_ROTL_CA_CA0_MASK)
 
#define CAU_ROTL_CA_CA1_MASK   (0xFFFFFFFFU)
 
#define CAU_ROTL_CA_CA1_SHIFT   (0U)
 
#define CAU_ROTL_CA_CA1(x)   (((uint32_t)(((uint32_t)(x)) << CAU_ROTL_CA_CA1_SHIFT)) & CAU_ROTL_CA_CA1_MASK)
 
#define CAU_ROTL_CA_CA2_MASK   (0xFFFFFFFFU)
 
#define CAU_ROTL_CA_CA2_SHIFT   (0U)
 
#define CAU_ROTL_CA_CA2(x)   (((uint32_t)(((uint32_t)(x)) << CAU_ROTL_CA_CA2_SHIFT)) & CAU_ROTL_CA_CA2_MASK)
 
#define CAU_ROTL_CA_CA3_MASK   (0xFFFFFFFFU)
 
#define CAU_ROTL_CA_CA3_SHIFT   (0U)
 
#define CAU_ROTL_CA_CA3(x)   (((uint32_t)(((uint32_t)(x)) << CAU_ROTL_CA_CA3_SHIFT)) & CAU_ROTL_CA_CA3_MASK)
 
#define CAU_ROTL_CA_CA4_MASK   (0xFFFFFFFFU)
 
#define CAU_ROTL_CA_CA4_SHIFT   (0U)
 
#define CAU_ROTL_CA_CA4(x)   (((uint32_t)(((uint32_t)(x)) << CAU_ROTL_CA_CA4_SHIFT)) & CAU_ROTL_CA_CA4_MASK)
 
#define CAU_ROTL_CA_CA5_MASK   (0xFFFFFFFFU)
 
#define CAU_ROTL_CA_CA5_SHIFT   (0U)
 
#define CAU_ROTL_CA_CA5(x)   (((uint32_t)(((uint32_t)(x)) << CAU_ROTL_CA_CA5_SHIFT)) & CAU_ROTL_CA_CA5_MASK)
 
#define CAU_ROTL_CA_CA6_MASK   (0xFFFFFFFFU)
 
#define CAU_ROTL_CA_CA6_SHIFT   (0U)
 
#define CAU_ROTL_CA_CA6(x)   (((uint32_t)(((uint32_t)(x)) << CAU_ROTL_CA_CA6_SHIFT)) & CAU_ROTL_CA_CA6_MASK)
 
#define CAU_ROTL_CA_CA7_MASK   (0xFFFFFFFFU)
 
#define CAU_ROTL_CA_CA7_SHIFT   (0U)
 
#define CAU_ROTL_CA_CA7(x)   (((uint32_t)(((uint32_t)(x)) << CAU_ROTL_CA_CA7_SHIFT)) & CAU_ROTL_CA_CA7_MASK)
 
#define CAU_ROTL_CA_CA8_MASK   (0xFFFFFFFFU)
 
#define CAU_ROTL_CA_CA8_SHIFT   (0U)
 
#define CAU_ROTL_CA_CA8(x)   (((uint32_t)(((uint32_t)(x)) << CAU_ROTL_CA_CA8_SHIFT)) & CAU_ROTL_CA_CA8_MASK)
 
#define CAU_ROTL_CA_COUNT   (9U)
 
AESC_CASR - Status register - AES Column Operation command
#define CAU_AESC_CASR_IC_MASK   (0x1U)
 
#define CAU_AESC_CASR_IC_SHIFT   (0U)
 
#define CAU_AESC_CASR_IC(x)   (((uint32_t)(((uint32_t)(x)) << CAU_AESC_CASR_IC_SHIFT)) & CAU_AESC_CASR_IC_MASK)
 
#define CAU_AESC_CASR_DPE_MASK   (0x2U)
 
#define CAU_AESC_CASR_DPE_SHIFT   (1U)
 
#define CAU_AESC_CASR_DPE(x)   (((uint32_t)(((uint32_t)(x)) << CAU_AESC_CASR_DPE_SHIFT)) & CAU_AESC_CASR_DPE_MASK)
 
#define CAU_AESC_CASR_VER_MASK   (0xF0000000U)
 
#define CAU_AESC_CASR_VER_SHIFT   (28U)
 
#define CAU_AESC_CASR_VER(x)   (((uint32_t)(((uint32_t)(x)) << CAU_AESC_CASR_VER_SHIFT)) & CAU_AESC_CASR_VER_MASK)
 
AESC_CAA - Accumulator register - AES Column Operation command
#define CAU_AESC_CAA_ACC_MASK   (0xFFFFFFFFU)
 
#define CAU_AESC_CAA_ACC_SHIFT   (0U)
 
#define CAU_AESC_CAA_ACC(x)   (((uint32_t)(((uint32_t)(x)) << CAU_AESC_CAA_ACC_SHIFT)) & CAU_AESC_CAA_ACC_MASK)
 
AESC_CA - General Purpose Register 0 - AES Column Operation command..General Purpose Register 8 - AES Column Operation command
#define CAU_AESC_CA_CA0_MASK   (0xFFFFFFFFU)
 
#define CAU_AESC_CA_CA0_SHIFT   (0U)
 
#define CAU_AESC_CA_CA0(x)   (((uint32_t)(((uint32_t)(x)) << CAU_AESC_CA_CA0_SHIFT)) & CAU_AESC_CA_CA0_MASK)
 
#define CAU_AESC_CA_CA1_MASK   (0xFFFFFFFFU)
 
#define CAU_AESC_CA_CA1_SHIFT   (0U)
 
#define CAU_AESC_CA_CA1(x)   (((uint32_t)(((uint32_t)(x)) << CAU_AESC_CA_CA1_SHIFT)) & CAU_AESC_CA_CA1_MASK)
 
#define CAU_AESC_CA_CA2_MASK   (0xFFFFFFFFU)
 
#define CAU_AESC_CA_CA2_SHIFT   (0U)
 
#define CAU_AESC_CA_CA2(x)   (((uint32_t)(((uint32_t)(x)) << CAU_AESC_CA_CA2_SHIFT)) & CAU_AESC_CA_CA2_MASK)
 
#define CAU_AESC_CA_CA3_MASK   (0xFFFFFFFFU)
 
#define CAU_AESC_CA_CA3_SHIFT   (0U)
 
#define CAU_AESC_CA_CA3(x)   (((uint32_t)(((uint32_t)(x)) << CAU_AESC_CA_CA3_SHIFT)) & CAU_AESC_CA_CA3_MASK)
 
#define CAU_AESC_CA_CA4_MASK   (0xFFFFFFFFU)
 
#define CAU_AESC_CA_CA4_SHIFT   (0U)
 
#define CAU_AESC_CA_CA4(x)   (((uint32_t)(((uint32_t)(x)) << CAU_AESC_CA_CA4_SHIFT)) & CAU_AESC_CA_CA4_MASK)
 
#define CAU_AESC_CA_CA5_MASK   (0xFFFFFFFFU)
 
#define CAU_AESC_CA_CA5_SHIFT   (0U)
 
#define CAU_AESC_CA_CA5(x)   (((uint32_t)(((uint32_t)(x)) << CAU_AESC_CA_CA5_SHIFT)) & CAU_AESC_CA_CA5_MASK)
 
#define CAU_AESC_CA_CA6_MASK   (0xFFFFFFFFU)
 
#define CAU_AESC_CA_CA6_SHIFT   (0U)
 
#define CAU_AESC_CA_CA6(x)   (((uint32_t)(((uint32_t)(x)) << CAU_AESC_CA_CA6_SHIFT)) & CAU_AESC_CA_CA6_MASK)
 
#define CAU_AESC_CA_CA7_MASK   (0xFFFFFFFFU)
 
#define CAU_AESC_CA_CA7_SHIFT   (0U)
 
#define CAU_AESC_CA_CA7(x)   (((uint32_t)(((uint32_t)(x)) << CAU_AESC_CA_CA7_SHIFT)) & CAU_AESC_CA_CA7_MASK)
 
#define CAU_AESC_CA_CA8_MASK   (0xFFFFFFFFU)
 
#define CAU_AESC_CA_CA8_SHIFT   (0U)
 
#define CAU_AESC_CA_CA8(x)   (((uint32_t)(((uint32_t)(x)) << CAU_AESC_CA_CA8_SHIFT)) & CAU_AESC_CA_CA8_MASK)
 
#define CAU_AESC_CA_COUNT   (9U)
 
AESIC_CASR - Status register - AES Inverse Column Operation command
#define CAU_AESIC_CASR_IC_MASK   (0x1U)
 
#define CAU_AESIC_CASR_IC_SHIFT   (0U)
 
#define CAU_AESIC_CASR_IC(x)   (((uint32_t)(((uint32_t)(x)) << CAU_AESIC_CASR_IC_SHIFT)) & CAU_AESIC_CASR_IC_MASK)
 
#define CAU_AESIC_CASR_DPE_MASK   (0x2U)
 
#define CAU_AESIC_CASR_DPE_SHIFT   (1U)
 
#define CAU_AESIC_CASR_DPE(x)   (((uint32_t)(((uint32_t)(x)) << CAU_AESIC_CASR_DPE_SHIFT)) & CAU_AESIC_CASR_DPE_MASK)
 
#define CAU_AESIC_CASR_VER_MASK   (0xF0000000U)
 
#define CAU_AESIC_CASR_VER_SHIFT   (28U)
 
#define CAU_AESIC_CASR_VER(x)   (((uint32_t)(((uint32_t)(x)) << CAU_AESIC_CASR_VER_SHIFT)) & CAU_AESIC_CASR_VER_MASK)
 
AESIC_CAA - Accumulator register - AES Inverse Column Operation command
#define CAU_AESIC_CAA_ACC_MASK   (0xFFFFFFFFU)
 
#define CAU_AESIC_CAA_ACC_SHIFT   (0U)
 
#define CAU_AESIC_CAA_ACC(x)   (((uint32_t)(((uint32_t)(x)) << CAU_AESIC_CAA_ACC_SHIFT)) & CAU_AESIC_CAA_ACC_MASK)
 
AESIC_CA - General Purpose Register 0 - AES Inverse Column Operation command..General Purpose Register 8 - AES Inverse Column Operation command
#define CAU_AESIC_CA_CA0_MASK   (0xFFFFFFFFU)
 
#define CAU_AESIC_CA_CA0_SHIFT   (0U)
 
#define CAU_AESIC_CA_CA0(x)   (((uint32_t)(((uint32_t)(x)) << CAU_AESIC_CA_CA0_SHIFT)) & CAU_AESIC_CA_CA0_MASK)
 
#define CAU_AESIC_CA_CA1_MASK   (0xFFFFFFFFU)
 
#define CAU_AESIC_CA_CA1_SHIFT   (0U)
 
#define CAU_AESIC_CA_CA1(x)   (((uint32_t)(((uint32_t)(x)) << CAU_AESIC_CA_CA1_SHIFT)) & CAU_AESIC_CA_CA1_MASK)
 
#define CAU_AESIC_CA_CA2_MASK   (0xFFFFFFFFU)
 
#define CAU_AESIC_CA_CA2_SHIFT   (0U)
 
#define CAU_AESIC_CA_CA2(x)   (((uint32_t)(((uint32_t)(x)) << CAU_AESIC_CA_CA2_SHIFT)) & CAU_AESIC_CA_CA2_MASK)
 
#define CAU_AESIC_CA_CA3_MASK   (0xFFFFFFFFU)
 
#define CAU_AESIC_CA_CA3_SHIFT   (0U)
 
#define CAU_AESIC_CA_CA3(x)   (((uint32_t)(((uint32_t)(x)) << CAU_AESIC_CA_CA3_SHIFT)) & CAU_AESIC_CA_CA3_MASK)
 
#define CAU_AESIC_CA_CA4_MASK   (0xFFFFFFFFU)
 
#define CAU_AESIC_CA_CA4_SHIFT   (0U)
 
#define CAU_AESIC_CA_CA4(x)   (((uint32_t)(((uint32_t)(x)) << CAU_AESIC_CA_CA4_SHIFT)) & CAU_AESIC_CA_CA4_MASK)
 
#define CAU_AESIC_CA_CA5_MASK   (0xFFFFFFFFU)
 
#define CAU_AESIC_CA_CA5_SHIFT   (0U)
 
#define CAU_AESIC_CA_CA5(x)   (((uint32_t)(((uint32_t)(x)) << CAU_AESIC_CA_CA5_SHIFT)) & CAU_AESIC_CA_CA5_MASK)
 
#define CAU_AESIC_CA_CA6_MASK   (0xFFFFFFFFU)
 
#define CAU_AESIC_CA_CA6_SHIFT   (0U)
 
#define CAU_AESIC_CA_CA6(x)   (((uint32_t)(((uint32_t)(x)) << CAU_AESIC_CA_CA6_SHIFT)) & CAU_AESIC_CA_CA6_MASK)
 
#define CAU_AESIC_CA_CA7_MASK   (0xFFFFFFFFU)
 
#define CAU_AESIC_CA_CA7_SHIFT   (0U)
 
#define CAU_AESIC_CA_CA7(x)   (((uint32_t)(((uint32_t)(x)) << CAU_AESIC_CA_CA7_SHIFT)) & CAU_AESIC_CA_CA7_MASK)
 
#define CAU_AESIC_CA_CA8_MASK   (0xFFFFFFFFU)
 
#define CAU_AESIC_CA_CA8_SHIFT   (0U)
 
#define CAU_AESIC_CA_CA8(x)   (((uint32_t)(((uint32_t)(x)) << CAU_AESIC_CA_CA8_SHIFT)) & CAU_AESIC_CA_CA8_MASK)
 
#define CAU_AESIC_CA_COUNT   (9U)
 
CR0 - CMP Control Register 0
#define CMP_CR0_HYSTCTR_MASK   (0x3U)
 
#define CMP_CR0_HYSTCTR_SHIFT   (0U)
 
#define CMP_CR0_HYSTCTR(x)   (((uint8_t)(((uint8_t)(x)) << CMP_CR0_HYSTCTR_SHIFT)) & CMP_CR0_HYSTCTR_MASK)
 
#define CMP_CR0_FILTER_CNT_MASK   (0x70U)
 
#define CMP_CR0_FILTER_CNT_SHIFT   (4U)
 
#define CMP_CR0_FILTER_CNT(x)   (((uint8_t)(((uint8_t)(x)) << CMP_CR0_FILTER_CNT_SHIFT)) & CMP_CR0_FILTER_CNT_MASK)
 
CR1 - CMP Control Register 1
#define CMP_CR1_EN_MASK   (0x1U)
 
#define CMP_CR1_EN_SHIFT   (0U)
 
#define CMP_CR1_EN(x)   (((uint8_t)(((uint8_t)(x)) << CMP_CR1_EN_SHIFT)) & CMP_CR1_EN_MASK)
 
#define CMP_CR1_OPE_MASK   (0x2U)
 
#define CMP_CR1_OPE_SHIFT   (1U)
 
#define CMP_CR1_OPE(x)   (((uint8_t)(((uint8_t)(x)) << CMP_CR1_OPE_SHIFT)) & CMP_CR1_OPE_MASK)
 
#define CMP_CR1_COS_MASK   (0x4U)
 
#define CMP_CR1_COS_SHIFT   (2U)
 
#define CMP_CR1_COS(x)   (((uint8_t)(((uint8_t)(x)) << CMP_CR1_COS_SHIFT)) & CMP_CR1_COS_MASK)
 
#define CMP_CR1_INV_MASK   (0x8U)
 
#define CMP_CR1_INV_SHIFT   (3U)
 
#define CMP_CR1_INV(x)   (((uint8_t)(((uint8_t)(x)) << CMP_CR1_INV_SHIFT)) & CMP_CR1_INV_MASK)
 
#define CMP_CR1_PMODE_MASK   (0x10U)
 
#define CMP_CR1_PMODE_SHIFT   (4U)
 
#define CMP_CR1_PMODE(x)   (((uint8_t)(((uint8_t)(x)) << CMP_CR1_PMODE_SHIFT)) & CMP_CR1_PMODE_MASK)
 
#define CMP_CR1_WE_MASK   (0x40U)
 
#define CMP_CR1_WE_SHIFT   (6U)
 
#define CMP_CR1_WE(x)   (((uint8_t)(((uint8_t)(x)) << CMP_CR1_WE_SHIFT)) & CMP_CR1_WE_MASK)
 
#define CMP_CR1_SE_MASK   (0x80U)
 
#define CMP_CR1_SE_SHIFT   (7U)
 
#define CMP_CR1_SE(x)   (((uint8_t)(((uint8_t)(x)) << CMP_CR1_SE_SHIFT)) & CMP_CR1_SE_MASK)
 
FPR - CMP Filter Period Register
#define CMP_FPR_FILT_PER_MASK   (0xFFU)
 
#define CMP_FPR_FILT_PER_SHIFT   (0U)
 
#define CMP_FPR_FILT_PER(x)   (((uint8_t)(((uint8_t)(x)) << CMP_FPR_FILT_PER_SHIFT)) & CMP_FPR_FILT_PER_MASK)
 
SCR - CMP Status and Control Register
#define CMP_SCR_COUT_MASK   (0x1U)
 
#define CMP_SCR_COUT_SHIFT   (0U)
 
#define CMP_SCR_COUT(x)   (((uint8_t)(((uint8_t)(x)) << CMP_SCR_COUT_SHIFT)) & CMP_SCR_COUT_MASK)
 
#define CMP_SCR_CFF_MASK   (0x2U)
 
#define CMP_SCR_CFF_SHIFT   (1U)
 
#define CMP_SCR_CFF(x)   (((uint8_t)(((uint8_t)(x)) << CMP_SCR_CFF_SHIFT)) & CMP_SCR_CFF_MASK)
 
#define CMP_SCR_CFR_MASK   (0x4U)
 
#define CMP_SCR_CFR_SHIFT   (2U)
 
#define CMP_SCR_CFR(x)   (((uint8_t)(((uint8_t)(x)) << CMP_SCR_CFR_SHIFT)) & CMP_SCR_CFR_MASK)
 
#define CMP_SCR_IEF_MASK   (0x8U)
 
#define CMP_SCR_IEF_SHIFT   (3U)
 
#define CMP_SCR_IEF(x)   (((uint8_t)(((uint8_t)(x)) << CMP_SCR_IEF_SHIFT)) & CMP_SCR_IEF_MASK)
 
#define CMP_SCR_IER_MASK   (0x10U)
 
#define CMP_SCR_IER_SHIFT   (4U)
 
#define CMP_SCR_IER(x)   (((uint8_t)(((uint8_t)(x)) << CMP_SCR_IER_SHIFT)) & CMP_SCR_IER_MASK)
 
#define CMP_SCR_DMAEN_MASK   (0x40U)
 
#define CMP_SCR_DMAEN_SHIFT   (6U)
 
#define CMP_SCR_DMAEN(x)   (((uint8_t)(((uint8_t)(x)) << CMP_SCR_DMAEN_SHIFT)) & CMP_SCR_DMAEN_MASK)
 
DACCR - DAC Control Register
#define CMP_DACCR_VOSEL_MASK   (0x3FU)
 
#define CMP_DACCR_VOSEL_SHIFT   (0U)
 
#define CMP_DACCR_VOSEL(x)   (((uint8_t)(((uint8_t)(x)) << CMP_DACCR_VOSEL_SHIFT)) & CMP_DACCR_VOSEL_MASK)
 
#define CMP_DACCR_VRSEL_MASK   (0x40U)
 
#define CMP_DACCR_VRSEL_SHIFT   (6U)
 
#define CMP_DACCR_VRSEL(x)   (((uint8_t)(((uint8_t)(x)) << CMP_DACCR_VRSEL_SHIFT)) & CMP_DACCR_VRSEL_MASK)
 
#define CMP_DACCR_DACEN_MASK   (0x80U)
 
#define CMP_DACCR_DACEN_SHIFT   (7U)
 
#define CMP_DACCR_DACEN(x)   (((uint8_t)(((uint8_t)(x)) << CMP_DACCR_DACEN_SHIFT)) & CMP_DACCR_DACEN_MASK)
 
MUXCR - MUX Control Register
#define CMP_MUXCR_MSEL_MASK   (0x7U)
 
#define CMP_MUXCR_MSEL_SHIFT   (0U)
 
#define CMP_MUXCR_MSEL(x)   (((uint8_t)(((uint8_t)(x)) << CMP_MUXCR_MSEL_SHIFT)) & CMP_MUXCR_MSEL_MASK)
 
#define CMP_MUXCR_PSEL_MASK   (0x38U)
 
#define CMP_MUXCR_PSEL_SHIFT   (3U)
 
#define CMP_MUXCR_PSEL(x)   (((uint8_t)(((uint8_t)(x)) << CMP_MUXCR_PSEL_SHIFT)) & CMP_MUXCR_PSEL_MASK)
 
#define CMP_MUXCR_PSTM_MASK   (0x80U)
 
#define CMP_MUXCR_PSTM_SHIFT   (7U)
 
#define CMP_MUXCR_PSTM(x)   (((uint8_t)(((uint8_t)(x)) << CMP_MUXCR_PSTM_SHIFT)) & CMP_MUXCR_PSTM_MASK)
 
CGH1 - CMT Carrier Generator High Data Register 1
#define CMT_CGH1_PH_MASK   (0xFFU)
 
#define CMT_CGH1_PH_SHIFT   (0U)
 
#define CMT_CGH1_PH(x)   (((uint8_t)(((uint8_t)(x)) << CMT_CGH1_PH_SHIFT)) & CMT_CGH1_PH_MASK)
 
CGL1 - CMT Carrier Generator Low Data Register 1
#define CMT_CGL1_PL_MASK   (0xFFU)
 
#define CMT_CGL1_PL_SHIFT   (0U)
 
#define CMT_CGL1_PL(x)   (((uint8_t)(((uint8_t)(x)) << CMT_CGL1_PL_SHIFT)) & CMT_CGL1_PL_MASK)
 
CGH2 - CMT Carrier Generator High Data Register 2
#define CMT_CGH2_SH_MASK   (0xFFU)
 
#define CMT_CGH2_SH_SHIFT   (0U)
 
#define CMT_CGH2_SH(x)   (((uint8_t)(((uint8_t)(x)) << CMT_CGH2_SH_SHIFT)) & CMT_CGH2_SH_MASK)
 
CGL2 - CMT Carrier Generator Low Data Register 2
#define CMT_CGL2_SL_MASK   (0xFFU)
 
#define CMT_CGL2_SL_SHIFT   (0U)
 
#define CMT_CGL2_SL(x)   (((uint8_t)(((uint8_t)(x)) << CMT_CGL2_SL_SHIFT)) & CMT_CGL2_SL_MASK)
 
OC - CMT Output Control Register
#define CMT_OC_IROPEN_MASK   (0x20U)
 
#define CMT_OC_IROPEN_SHIFT   (5U)
 
#define CMT_OC_IROPEN(x)   (((uint8_t)(((uint8_t)(x)) << CMT_OC_IROPEN_SHIFT)) & CMT_OC_IROPEN_MASK)
 
#define CMT_OC_CMTPOL_MASK   (0x40U)
 
#define CMT_OC_CMTPOL_SHIFT   (6U)
 
#define CMT_OC_CMTPOL(x)   (((uint8_t)(((uint8_t)(x)) << CMT_OC_CMTPOL_SHIFT)) & CMT_OC_CMTPOL_MASK)
 
#define CMT_OC_IROL_MASK   (0x80U)
 
#define CMT_OC_IROL_SHIFT   (7U)
 
#define CMT_OC_IROL(x)   (((uint8_t)(((uint8_t)(x)) << CMT_OC_IROL_SHIFT)) & CMT_OC_IROL_MASK)
 
MSC - CMT Modulator Status and Control Register
#define CMT_MSC_MCGEN_MASK   (0x1U)
 
#define CMT_MSC_MCGEN_SHIFT   (0U)
 
#define CMT_MSC_MCGEN(x)   (((uint8_t)(((uint8_t)(x)) << CMT_MSC_MCGEN_SHIFT)) & CMT_MSC_MCGEN_MASK)
 
#define CMT_MSC_EOCIE_MASK   (0x2U)
 
#define CMT_MSC_EOCIE_SHIFT   (1U)
 
#define CMT_MSC_EOCIE(x)   (((uint8_t)(((uint8_t)(x)) << CMT_MSC_EOCIE_SHIFT)) & CMT_MSC_EOCIE_MASK)
 
#define CMT_MSC_FSK_MASK   (0x4U)
 
#define CMT_MSC_FSK_SHIFT   (2U)
 
#define CMT_MSC_FSK(x)   (((uint8_t)(((uint8_t)(x)) << CMT_MSC_FSK_SHIFT)) & CMT_MSC_FSK_MASK)
 
#define CMT_MSC_BASE_MASK   (0x8U)
 
#define CMT_MSC_BASE_SHIFT   (3U)
 
#define CMT_MSC_BASE(x)   (((uint8_t)(((uint8_t)(x)) << CMT_MSC_BASE_SHIFT)) & CMT_MSC_BASE_MASK)
 
#define CMT_MSC_EXSPC_MASK   (0x10U)
 
#define CMT_MSC_EXSPC_SHIFT   (4U)
 
#define CMT_MSC_EXSPC(x)   (((uint8_t)(((uint8_t)(x)) << CMT_MSC_EXSPC_SHIFT)) & CMT_MSC_EXSPC_MASK)
 
#define CMT_MSC_CMTDIV_MASK   (0x60U)
 
#define CMT_MSC_CMTDIV_SHIFT   (5U)
 
#define CMT_MSC_CMTDIV(x)   (((uint8_t)(((uint8_t)(x)) << CMT_MSC_CMTDIV_SHIFT)) & CMT_MSC_CMTDIV_MASK)
 
#define CMT_MSC_EOCF_MASK   (0x80U)
 
#define CMT_MSC_EOCF_SHIFT   (7U)
 
#define CMT_MSC_EOCF(x)   (((uint8_t)(((uint8_t)(x)) << CMT_MSC_EOCF_SHIFT)) & CMT_MSC_EOCF_MASK)
 
CMD1 - CMT Modulator Data Register Mark High
#define CMT_CMD1_MB_MASK   (0xFFU)
 
#define CMT_CMD1_MB_SHIFT   (0U)
 
#define CMT_CMD1_MB(x)   (((uint8_t)(((uint8_t)(x)) << CMT_CMD1_MB_SHIFT)) & CMT_CMD1_MB_MASK)
 
CMD2 - CMT Modulator Data Register Mark Low
#define CMT_CMD2_MB_MASK   (0xFFU)
 
#define CMT_CMD2_MB_SHIFT   (0U)
 
#define CMT_CMD2_MB(x)   (((uint8_t)(((uint8_t)(x)) << CMT_CMD2_MB_SHIFT)) & CMT_CMD2_MB_MASK)
 
CMD3 - CMT Modulator Data Register Space High
#define CMT_CMD3_SB_MASK   (0xFFU)
 
#define CMT_CMD3_SB_SHIFT   (0U)
 
#define CMT_CMD3_SB(x)   (((uint8_t)(((uint8_t)(x)) << CMT_CMD3_SB_SHIFT)) & CMT_CMD3_SB_MASK)
 
CMD4 - CMT Modulator Data Register Space Low
#define CMT_CMD4_SB_MASK   (0xFFU)
 
#define CMT_CMD4_SB_SHIFT   (0U)
 
#define CMT_CMD4_SB(x)   (((uint8_t)(((uint8_t)(x)) << CMT_CMD4_SB_SHIFT)) & CMT_CMD4_SB_MASK)
 
PPS - CMT Primary Prescaler Register
#define CMT_PPS_PPSDIV_MASK   (0xFU)
 
#define CMT_PPS_PPSDIV_SHIFT   (0U)
 
#define CMT_PPS_PPSDIV(x)   (((uint8_t)(((uint8_t)(x)) << CMT_PPS_PPSDIV_SHIFT)) & CMT_PPS_PPSDIV_MASK)
 
DMA - CMT Direct Memory Access Register
#define CMT_DMA_DMA_MASK   (0x1U)
 
#define CMT_DMA_DMA_SHIFT   (0U)
 
#define CMT_DMA_DMA(x)   (((uint8_t)(((uint8_t)(x)) << CMT_DMA_DMA_SHIFT)) & CMT_DMA_DMA_MASK)
 
DATAL - CRC_DATAL register.
#define CRC_DATAL_DATAL_MASK   (0xFFFFU)
 
#define CRC_DATAL_DATAL_SHIFT   (0U)
 
#define CRC_DATAL_DATAL(x)   (((uint16_t)(((uint16_t)(x)) << CRC_DATAL_DATAL_SHIFT)) & CRC_DATAL_DATAL_MASK)
 
DATAH - CRC_DATAH register.
#define CRC_DATAH_DATAH_MASK   (0xFFFFU)
 
#define CRC_DATAH_DATAH_SHIFT   (0U)
 
#define CRC_DATAH_DATAH(x)   (((uint16_t)(((uint16_t)(x)) << CRC_DATAH_DATAH_SHIFT)) & CRC_DATAH_DATAH_MASK)
 
DATA - CRC Data register
#define CRC_DATA_LL_MASK   (0xFFU)
 
#define CRC_DATA_LL_SHIFT   (0U)
 
#define CRC_DATA_LL(x)   (((uint32_t)(((uint32_t)(x)) << CRC_DATA_LL_SHIFT)) & CRC_DATA_LL_MASK)
 
#define CRC_DATA_LU_MASK   (0xFF00U)
 
#define CRC_DATA_LU_SHIFT   (8U)
 
#define CRC_DATA_LU(x)   (((uint32_t)(((uint32_t)(x)) << CRC_DATA_LU_SHIFT)) & CRC_DATA_LU_MASK)
 
#define CRC_DATA_HL_MASK   (0xFF0000U)
 
#define CRC_DATA_HL_SHIFT   (16U)
 
#define CRC_DATA_HL(x)   (((uint32_t)(((uint32_t)(x)) << CRC_DATA_HL_SHIFT)) & CRC_DATA_HL_MASK)
 
#define CRC_DATA_HU_MASK   (0xFF000000U)
 
#define CRC_DATA_HU_SHIFT   (24U)
 
#define CRC_DATA_HU(x)   (((uint32_t)(((uint32_t)(x)) << CRC_DATA_HU_SHIFT)) & CRC_DATA_HU_MASK)
 
DATALL - CRC_DATALL register.
#define CRC_DATALL_DATALL_MASK   (0xFFU)
 
#define CRC_DATALL_DATALL_SHIFT   (0U)
 
#define CRC_DATALL_DATALL(x)   (((uint8_t)(((uint8_t)(x)) << CRC_DATALL_DATALL_SHIFT)) & CRC_DATALL_DATALL_MASK)
 
DATALU - CRC_DATALU register.
#define CRC_DATALU_DATALU_MASK   (0xFFU)
 
#define CRC_DATALU_DATALU_SHIFT   (0U)
 
#define CRC_DATALU_DATALU(x)   (((uint8_t)(((uint8_t)(x)) << CRC_DATALU_DATALU_SHIFT)) & CRC_DATALU_DATALU_MASK)
 
DATAHL - CRC_DATAHL register.
#define CRC_DATAHL_DATAHL_MASK   (0xFFU)
 
#define CRC_DATAHL_DATAHL_SHIFT   (0U)
 
#define CRC_DATAHL_DATAHL(x)   (((uint8_t)(((uint8_t)(x)) << CRC_DATAHL_DATAHL_SHIFT)) & CRC_DATAHL_DATAHL_MASK)
 
DATAHU - CRC_DATAHU register.
#define CRC_DATAHU_DATAHU_MASK   (0xFFU)
 
#define CRC_DATAHU_DATAHU_SHIFT   (0U)
 
#define CRC_DATAHU_DATAHU(x)   (((uint8_t)(((uint8_t)(x)) << CRC_DATAHU_DATAHU_SHIFT)) & CRC_DATAHU_DATAHU_MASK)
 
GPOLYL - CRC_GPOLYL register.
#define CRC_GPOLYL_GPOLYL_MASK   (0xFFFFU)
 
#define CRC_GPOLYL_GPOLYL_SHIFT   (0U)
 
#define CRC_GPOLYL_GPOLYL(x)   (((uint16_t)(((uint16_t)(x)) << CRC_GPOLYL_GPOLYL_SHIFT)) & CRC_GPOLYL_GPOLYL_MASK)
 
GPOLYH - CRC_GPOLYH register.
#define CRC_GPOLYH_GPOLYH_MASK   (0xFFFFU)
 
#define CRC_GPOLYH_GPOLYH_SHIFT   (0U)
 
#define CRC_GPOLYH_GPOLYH(x)   (((uint16_t)(((uint16_t)(x)) << CRC_GPOLYH_GPOLYH_SHIFT)) & CRC_GPOLYH_GPOLYH_MASK)
 
GPOLY - CRC Polynomial register
#define CRC_GPOLY_LOW_MASK   (0xFFFFU)
 
#define CRC_GPOLY_LOW_SHIFT   (0U)
 
#define CRC_GPOLY_LOW(x)   (((uint32_t)(((uint32_t)(x)) << CRC_GPOLY_LOW_SHIFT)) & CRC_GPOLY_LOW_MASK)
 
#define CRC_GPOLY_HIGH_MASK   (0xFFFF0000U)
 
#define CRC_GPOLY_HIGH_SHIFT   (16U)
 
#define CRC_GPOLY_HIGH(x)   (((uint32_t)(((uint32_t)(x)) << CRC_GPOLY_HIGH_SHIFT)) & CRC_GPOLY_HIGH_MASK)
 
GPOLYLL - CRC_GPOLYLL register.
#define CRC_GPOLYLL_GPOLYLL_MASK   (0xFFU)
 
#define CRC_GPOLYLL_GPOLYLL_SHIFT   (0U)
 
#define CRC_GPOLYLL_GPOLYLL(x)   (((uint8_t)(((uint8_t)(x)) << CRC_GPOLYLL_GPOLYLL_SHIFT)) & CRC_GPOLYLL_GPOLYLL_MASK)
 
GPOLYLU - CRC_GPOLYLU register.
#define CRC_GPOLYLU_GPOLYLU_MASK   (0xFFU)
 
#define CRC_GPOLYLU_GPOLYLU_SHIFT   (0U)
 
#define CRC_GPOLYLU_GPOLYLU(x)   (((uint8_t)(((uint8_t)(x)) << CRC_GPOLYLU_GPOLYLU_SHIFT)) & CRC_GPOLYLU_GPOLYLU_MASK)
 
GPOLYHL - CRC_GPOLYHL register.
#define CRC_GPOLYHL_GPOLYHL_MASK   (0xFFU)
 
#define CRC_GPOLYHL_GPOLYHL_SHIFT   (0U)
 
#define CRC_GPOLYHL_GPOLYHL(x)   (((uint8_t)(((uint8_t)(x)) << CRC_GPOLYHL_GPOLYHL_SHIFT)) & CRC_GPOLYHL_GPOLYHL_MASK)
 
GPOLYHU - CRC_GPOLYHU register.
#define CRC_GPOLYHU_GPOLYHU_MASK   (0xFFU)
 
#define CRC_GPOLYHU_GPOLYHU_SHIFT   (0U)
 
#define CRC_GPOLYHU_GPOLYHU(x)   (((uint8_t)(((uint8_t)(x)) << CRC_GPOLYHU_GPOLYHU_SHIFT)) & CRC_GPOLYHU_GPOLYHU_MASK)
 
CTRL - CRC Control register
#define CRC_CTRL_TCRC_MASK   (0x1000000U)
 
#define CRC_CTRL_TCRC_SHIFT   (24U)
 
#define CRC_CTRL_TCRC(x)   (((uint32_t)(((uint32_t)(x)) << CRC_CTRL_TCRC_SHIFT)) & CRC_CTRL_TCRC_MASK)
 
#define CRC_CTRL_WAS_MASK   (0x2000000U)
 
#define CRC_CTRL_WAS_SHIFT   (25U)
 
#define CRC_CTRL_WAS(x)   (((uint32_t)(((uint32_t)(x)) << CRC_CTRL_WAS_SHIFT)) & CRC_CTRL_WAS_MASK)
 
#define CRC_CTRL_FXOR_MASK   (0x4000000U)
 
#define CRC_CTRL_FXOR_SHIFT   (26U)
 
#define CRC_CTRL_FXOR(x)   (((uint32_t)(((uint32_t)(x)) << CRC_CTRL_FXOR_SHIFT)) & CRC_CTRL_FXOR_MASK)
 
#define CRC_CTRL_TOTR_MASK   (0x30000000U)
 
#define CRC_CTRL_TOTR_SHIFT   (28U)
 
#define CRC_CTRL_TOTR(x)   (((uint32_t)(((uint32_t)(x)) << CRC_CTRL_TOTR_SHIFT)) & CRC_CTRL_TOTR_MASK)
 
#define CRC_CTRL_TOT_MASK   (0xC0000000U)
 
#define CRC_CTRL_TOT_SHIFT   (30U)
 
#define CRC_CTRL_TOT(x)   (((uint32_t)(((uint32_t)(x)) << CRC_CTRL_TOT_SHIFT)) & CRC_CTRL_TOT_MASK)
 
CTRLHU - CRC_CTRLHU register.
#define CRC_CTRLHU_TCRC_MASK   (0x1U)
 
#define CRC_CTRLHU_TCRC_SHIFT   (0U)
 
#define CRC_CTRLHU_TCRC(x)   (((uint8_t)(((uint8_t)(x)) << CRC_CTRLHU_TCRC_SHIFT)) & CRC_CTRLHU_TCRC_MASK)
 
#define CRC_CTRLHU_WAS_MASK   (0x2U)
 
#define CRC_CTRLHU_WAS_SHIFT   (1U)
 
#define CRC_CTRLHU_WAS(x)   (((uint8_t)(((uint8_t)(x)) << CRC_CTRLHU_WAS_SHIFT)) & CRC_CTRLHU_WAS_MASK)
 
#define CRC_CTRLHU_FXOR_MASK   (0x4U)
 
#define CRC_CTRLHU_FXOR_SHIFT   (2U)
 
#define CRC_CTRLHU_FXOR(x)   (((uint8_t)(((uint8_t)(x)) << CRC_CTRLHU_FXOR_SHIFT)) & CRC_CTRLHU_FXOR_MASK)
 
#define CRC_CTRLHU_TOTR_MASK   (0x30U)
 
#define CRC_CTRLHU_TOTR_SHIFT   (4U)
 
#define CRC_CTRLHU_TOTR(x)   (((uint8_t)(((uint8_t)(x)) << CRC_CTRLHU_TOTR_SHIFT)) & CRC_CTRLHU_TOTR_MASK)
 
#define CRC_CTRLHU_TOT_MASK   (0xC0U)
 
#define CRC_CTRLHU_TOT_SHIFT   (6U)
 
#define CRC_CTRLHU_TOT(x)   (((uint8_t)(((uint8_t)(x)) << CRC_CTRLHU_TOT_SHIFT)) & CRC_CTRLHU_TOT_MASK)
 
DATL - DAC Data Low Register
#define DAC_DATL_DATA0_MASK   (0xFFU)
 
#define DAC_DATL_DATA0_SHIFT   (0U)
 
#define DAC_DATL_DATA0(x)   (((uint8_t)(((uint8_t)(x)) << DAC_DATL_DATA0_SHIFT)) & DAC_DATL_DATA0_MASK)
 
#define DAC_DATL_COUNT   (16U)
 
DATH - DAC Data High Register
#define DAC_DATH_DATA1_MASK   (0xFU)
 
#define DAC_DATH_DATA1_SHIFT   (0U)
 
#define DAC_DATH_DATA1(x)   (((uint8_t)(((uint8_t)(x)) << DAC_DATH_DATA1_SHIFT)) & DAC_DATH_DATA1_MASK)
 
#define DAC_DATH_COUNT   (16U)
 
SR - DAC Status Register
#define DAC_SR_DACBFRPBF_MASK   (0x1U)
 
#define DAC_SR_DACBFRPBF_SHIFT   (0U)
 
#define DAC_SR_DACBFRPBF(x)   (((uint8_t)(((uint8_t)(x)) << DAC_SR_DACBFRPBF_SHIFT)) & DAC_SR_DACBFRPBF_MASK)
 
#define DAC_SR_DACBFRPTF_MASK   (0x2U)
 
#define DAC_SR_DACBFRPTF_SHIFT   (1U)
 
#define DAC_SR_DACBFRPTF(x)   (((uint8_t)(((uint8_t)(x)) << DAC_SR_DACBFRPTF_SHIFT)) & DAC_SR_DACBFRPTF_MASK)
 
#define DAC_SR_DACBFWMF_MASK   (0x4U)
 
#define DAC_SR_DACBFWMF_SHIFT   (2U)
 
#define DAC_SR_DACBFWMF(x)   (((uint8_t)(((uint8_t)(x)) << DAC_SR_DACBFWMF_SHIFT)) & DAC_SR_DACBFWMF_MASK)
 
C0 - DAC Control Register
#define DAC_C0_DACBBIEN_MASK   (0x1U)
 
#define DAC_C0_DACBBIEN_SHIFT   (0U)
 
#define DAC_C0_DACBBIEN(x)   (((uint8_t)(((uint8_t)(x)) << DAC_C0_DACBBIEN_SHIFT)) & DAC_C0_DACBBIEN_MASK)
 
#define DAC_C0_DACBTIEN_MASK   (0x2U)
 
#define DAC_C0_DACBTIEN_SHIFT   (1U)
 
#define DAC_C0_DACBTIEN(x)   (((uint8_t)(((uint8_t)(x)) << DAC_C0_DACBTIEN_SHIFT)) & DAC_C0_DACBTIEN_MASK)
 
#define DAC_C0_DACBWIEN_MASK   (0x4U)
 
#define DAC_C0_DACBWIEN_SHIFT   (2U)
 
#define DAC_C0_DACBWIEN(x)   (((uint8_t)(((uint8_t)(x)) << DAC_C0_DACBWIEN_SHIFT)) & DAC_C0_DACBWIEN_MASK)
 
#define DAC_C0_LPEN_MASK   (0x8U)
 
#define DAC_C0_LPEN_SHIFT   (3U)
 
#define DAC_C0_LPEN(x)   (((uint8_t)(((uint8_t)(x)) << DAC_C0_LPEN_SHIFT)) & DAC_C0_LPEN_MASK)
 
#define DAC_C0_DACSWTRG_MASK   (0x10U)
 
#define DAC_C0_DACSWTRG_SHIFT   (4U)
 
#define DAC_C0_DACSWTRG(x)   (((uint8_t)(((uint8_t)(x)) << DAC_C0_DACSWTRG_SHIFT)) & DAC_C0_DACSWTRG_MASK)
 
#define DAC_C0_DACTRGSEL_MASK   (0x20U)
 
#define DAC_C0_DACTRGSEL_SHIFT   (5U)
 
#define DAC_C0_DACTRGSEL(x)   (((uint8_t)(((uint8_t)(x)) << DAC_C0_DACTRGSEL_SHIFT)) & DAC_C0_DACTRGSEL_MASK)
 
#define DAC_C0_DACRFS_MASK   (0x40U)
 
#define DAC_C0_DACRFS_SHIFT   (6U)
 
#define DAC_C0_DACRFS(x)   (((uint8_t)(((uint8_t)(x)) << DAC_C0_DACRFS_SHIFT)) & DAC_C0_DACRFS_MASK)
 
#define DAC_C0_DACEN_MASK   (0x80U)
 
#define DAC_C0_DACEN_SHIFT   (7U)
 
#define DAC_C0_DACEN(x)   (((uint8_t)(((uint8_t)(x)) << DAC_C0_DACEN_SHIFT)) & DAC_C0_DACEN_MASK)
 
C1 - DAC Control Register 1
#define DAC_C1_DACBFEN_MASK   (0x1U)
 
#define DAC_C1_DACBFEN_SHIFT   (0U)
 
#define DAC_C1_DACBFEN(x)   (((uint8_t)(((uint8_t)(x)) << DAC_C1_DACBFEN_SHIFT)) & DAC_C1_DACBFEN_MASK)
 
#define DAC_C1_DACBFMD_MASK   (0x6U)
 
#define DAC_C1_DACBFMD_SHIFT   (1U)
 
#define DAC_C1_DACBFMD(x)   (((uint8_t)(((uint8_t)(x)) << DAC_C1_DACBFMD_SHIFT)) & DAC_C1_DACBFMD_MASK)
 
#define DAC_C1_DACBFWM_MASK   (0x18U)
 
#define DAC_C1_DACBFWM_SHIFT   (3U)
 
#define DAC_C1_DACBFWM(x)   (((uint8_t)(((uint8_t)(x)) << DAC_C1_DACBFWM_SHIFT)) & DAC_C1_DACBFWM_MASK)
 
#define DAC_C1_DMAEN_MASK   (0x80U)
 
#define DAC_C1_DMAEN_SHIFT   (7U)
 
#define DAC_C1_DMAEN(x)   (((uint8_t)(((uint8_t)(x)) << DAC_C1_DMAEN_SHIFT)) & DAC_C1_DMAEN_MASK)
 
C2 - DAC Control Register 2
#define DAC_C2_DACBFUP_MASK   (0xFU)
 
#define DAC_C2_DACBFUP_SHIFT   (0U)
 
#define DAC_C2_DACBFUP(x)   (((uint8_t)(((uint8_t)(x)) << DAC_C2_DACBFUP_SHIFT)) & DAC_C2_DACBFUP_MASK)
 
#define DAC_C2_DACBFRP_MASK   (0xF0U)
 
#define DAC_C2_DACBFRP_SHIFT   (4U)
 
#define DAC_C2_DACBFRP(x)   (((uint8_t)(((uint8_t)(x)) << DAC_C2_DACBFRP_SHIFT)) & DAC_C2_DACBFRP_MASK)
 
CR - Control Register
#define DMA_CR_EDBG_MASK   (0x2U)
 
#define DMA_CR_EDBG_SHIFT   (1U)
 
#define DMA_CR_EDBG(x)   (((uint32_t)(((uint32_t)(x)) << DMA_CR_EDBG_SHIFT)) & DMA_CR_EDBG_MASK)
 
#define DMA_CR_ERCA_MASK   (0x4U)
 
#define DMA_CR_ERCA_SHIFT   (2U)
 
#define DMA_CR_ERCA(x)   (((uint32_t)(((uint32_t)(x)) << DMA_CR_ERCA_SHIFT)) & DMA_CR_ERCA_MASK)
 
#define DMA_CR_HOE_MASK   (0x10U)
 
#define DMA_CR_HOE_SHIFT   (4U)
 
#define DMA_CR_HOE(x)   (((uint32_t)(((uint32_t)(x)) << DMA_CR_HOE_SHIFT)) & DMA_CR_HOE_MASK)
 
#define DMA_CR_HALT_MASK   (0x20U)
 
#define DMA_CR_HALT_SHIFT   (5U)
 
#define DMA_CR_HALT(x)   (((uint32_t)(((uint32_t)(x)) << DMA_CR_HALT_SHIFT)) & DMA_CR_HALT_MASK)
 
#define DMA_CR_CLM_MASK   (0x40U)
 
#define DMA_CR_CLM_SHIFT   (6U)
 
#define DMA_CR_CLM(x)   (((uint32_t)(((uint32_t)(x)) << DMA_CR_CLM_SHIFT)) & DMA_CR_CLM_MASK)
 
#define DMA_CR_EMLM_MASK   (0x80U)
 
#define DMA_CR_EMLM_SHIFT   (7U)
 
#define DMA_CR_EMLM(x)   (((uint32_t)(((uint32_t)(x)) << DMA_CR_EMLM_SHIFT)) & DMA_CR_EMLM_MASK)
 
#define DMA_CR_ECX_MASK   (0x10000U)
 
#define DMA_CR_ECX_SHIFT   (16U)
 
#define DMA_CR_ECX(x)   (((uint32_t)(((uint32_t)(x)) << DMA_CR_ECX_SHIFT)) & DMA_CR_ECX_MASK)
 
#define DMA_CR_CX_MASK   (0x20000U)
 
#define DMA_CR_CX_SHIFT   (17U)
 
#define DMA_CR_CX(x)   (((uint32_t)(((uint32_t)(x)) << DMA_CR_CX_SHIFT)) & DMA_CR_CX_MASK)
 
#define MCM_CR_SRAMUAP_MASK   (0x3000000U)
 
#define MCM_CR_SRAMUAP_SHIFT   (24U)
 
#define MCM_CR_SRAMUAP(x)   (((uint32_t)(((uint32_t)(x)) << MCM_CR_SRAMUAP_SHIFT)) & MCM_CR_SRAMUAP_MASK)
 
#define MCM_CR_SRAMUWP_MASK   (0x4000000U)
 
#define MCM_CR_SRAMUWP_SHIFT   (26U)
 
#define MCM_CR_SRAMUWP(x)   (((uint32_t)(((uint32_t)(x)) << MCM_CR_SRAMUWP_SHIFT)) & MCM_CR_SRAMUWP_MASK)
 
#define MCM_CR_SRAMLAP_MASK   (0x30000000U)
 
#define MCM_CR_SRAMLAP_SHIFT   (28U)
 
#define MCM_CR_SRAMLAP(x)   (((uint32_t)(((uint32_t)(x)) << MCM_CR_SRAMLAP_SHIFT)) & MCM_CR_SRAMLAP_MASK)
 
#define MCM_CR_SRAMLWP_MASK   (0x40000000U)
 
#define MCM_CR_SRAMLWP_SHIFT   (30U)
 
#define MCM_CR_SRAMLWP(x)   (((uint32_t)(((uint32_t)(x)) << MCM_CR_SRAMLWP_SHIFT)) & MCM_CR_SRAMLWP_MASK)
 
ES - Error Status Register
#define DMA_ES_DBE_MASK   (0x1U)
 
#define DMA_ES_DBE_SHIFT   (0U)
 
#define DMA_ES_DBE(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ES_DBE_SHIFT)) & DMA_ES_DBE_MASK)
 
#define DMA_ES_SBE_MASK   (0x2U)
 
#define DMA_ES_SBE_SHIFT   (1U)
 
#define DMA_ES_SBE(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ES_SBE_SHIFT)) & DMA_ES_SBE_MASK)
 
#define DMA_ES_SGE_MASK   (0x4U)
 
#define DMA_ES_SGE_SHIFT   (2U)
 
#define DMA_ES_SGE(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ES_SGE_SHIFT)) & DMA_ES_SGE_MASK)
 
#define DMA_ES_NCE_MASK   (0x8U)
 
#define DMA_ES_NCE_SHIFT   (3U)
 
#define DMA_ES_NCE(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ES_NCE_SHIFT)) & DMA_ES_NCE_MASK)
 
#define DMA_ES_DOE_MASK   (0x10U)
 
#define DMA_ES_DOE_SHIFT   (4U)
 
#define DMA_ES_DOE(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ES_DOE_SHIFT)) & DMA_ES_DOE_MASK)
 
#define DMA_ES_DAE_MASK   (0x20U)
 
#define DMA_ES_DAE_SHIFT   (5U)
 
#define DMA_ES_DAE(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ES_DAE_SHIFT)) & DMA_ES_DAE_MASK)
 
#define DMA_ES_SOE_MASK   (0x40U)
 
#define DMA_ES_SOE_SHIFT   (6U)
 
#define DMA_ES_SOE(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ES_SOE_SHIFT)) & DMA_ES_SOE_MASK)
 
#define DMA_ES_SAE_MASK   (0x80U)
 
#define DMA_ES_SAE_SHIFT   (7U)
 
#define DMA_ES_SAE(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ES_SAE_SHIFT)) & DMA_ES_SAE_MASK)
 
#define DMA_ES_ERRCHN_MASK   (0xF00U)
 
#define DMA_ES_ERRCHN_SHIFT   (8U)
 
#define DMA_ES_ERRCHN(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ES_ERRCHN_SHIFT)) & DMA_ES_ERRCHN_MASK)
 
#define DMA_ES_CPE_MASK   (0x4000U)
 
#define DMA_ES_CPE_SHIFT   (14U)
 
#define DMA_ES_CPE(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ES_CPE_SHIFT)) & DMA_ES_CPE_MASK)
 
#define DMA_ES_ECX_MASK   (0x10000U)
 
#define DMA_ES_ECX_SHIFT   (16U)
 
#define DMA_ES_ECX(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ES_ECX_SHIFT)) & DMA_ES_ECX_MASK)
 
#define DMA_ES_VLD_MASK   (0x80000000U)
 
#define DMA_ES_VLD_SHIFT   (31U)
 
#define DMA_ES_VLD(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ES_VLD_SHIFT)) & DMA_ES_VLD_MASK)
 
ERQ - Enable Request Register
#define DMA_ERQ_ERQ0_MASK   (0x1U)
 
#define DMA_ERQ_ERQ0_SHIFT   (0U)
 
#define DMA_ERQ_ERQ0(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERQ_ERQ0_SHIFT)) & DMA_ERQ_ERQ0_MASK)
 
#define DMA_ERQ_ERQ1_MASK   (0x2U)
 
#define DMA_ERQ_ERQ1_SHIFT   (1U)
 
#define DMA_ERQ_ERQ1(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERQ_ERQ1_SHIFT)) & DMA_ERQ_ERQ1_MASK)
 
#define DMA_ERQ_ERQ2_MASK   (0x4U)
 
#define DMA_ERQ_ERQ2_SHIFT   (2U)
 
#define DMA_ERQ_ERQ2(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERQ_ERQ2_SHIFT)) & DMA_ERQ_ERQ2_MASK)
 
#define DMA_ERQ_ERQ3_MASK   (0x8U)
 
#define DMA_ERQ_ERQ3_SHIFT   (3U)
 
#define DMA_ERQ_ERQ3(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERQ_ERQ3_SHIFT)) & DMA_ERQ_ERQ3_MASK)
 
#define DMA_ERQ_ERQ4_MASK   (0x10U)
 
#define DMA_ERQ_ERQ4_SHIFT   (4U)
 
#define DMA_ERQ_ERQ4(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERQ_ERQ4_SHIFT)) & DMA_ERQ_ERQ4_MASK)
 
#define DMA_ERQ_ERQ5_MASK   (0x20U)
 
#define DMA_ERQ_ERQ5_SHIFT   (5U)
 
#define DMA_ERQ_ERQ5(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERQ_ERQ5_SHIFT)) & DMA_ERQ_ERQ5_MASK)
 
#define DMA_ERQ_ERQ6_MASK   (0x40U)
 
#define DMA_ERQ_ERQ6_SHIFT   (6U)
 
#define DMA_ERQ_ERQ6(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERQ_ERQ6_SHIFT)) & DMA_ERQ_ERQ6_MASK)
 
#define DMA_ERQ_ERQ7_MASK   (0x80U)
 
#define DMA_ERQ_ERQ7_SHIFT   (7U)
 
#define DMA_ERQ_ERQ7(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERQ_ERQ7_SHIFT)) & DMA_ERQ_ERQ7_MASK)
 
#define DMA_ERQ_ERQ8_MASK   (0x100U)
 
#define DMA_ERQ_ERQ8_SHIFT   (8U)
 
#define DMA_ERQ_ERQ8(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERQ_ERQ8_SHIFT)) & DMA_ERQ_ERQ8_MASK)
 
#define DMA_ERQ_ERQ9_MASK   (0x200U)
 
#define DMA_ERQ_ERQ9_SHIFT   (9U)
 
#define DMA_ERQ_ERQ9(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERQ_ERQ9_SHIFT)) & DMA_ERQ_ERQ9_MASK)
 
#define DMA_ERQ_ERQ10_MASK   (0x400U)
 
#define DMA_ERQ_ERQ10_SHIFT   (10U)
 
#define DMA_ERQ_ERQ10(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERQ_ERQ10_SHIFT)) & DMA_ERQ_ERQ10_MASK)
 
#define DMA_ERQ_ERQ11_MASK   (0x800U)
 
#define DMA_ERQ_ERQ11_SHIFT   (11U)
 
#define DMA_ERQ_ERQ11(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERQ_ERQ11_SHIFT)) & DMA_ERQ_ERQ11_MASK)
 
#define DMA_ERQ_ERQ12_MASK   (0x1000U)
 
#define DMA_ERQ_ERQ12_SHIFT   (12U)
 
#define DMA_ERQ_ERQ12(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERQ_ERQ12_SHIFT)) & DMA_ERQ_ERQ12_MASK)
 
#define DMA_ERQ_ERQ13_MASK   (0x2000U)
 
#define DMA_ERQ_ERQ13_SHIFT   (13U)
 
#define DMA_ERQ_ERQ13(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERQ_ERQ13_SHIFT)) & DMA_ERQ_ERQ13_MASK)
 
#define DMA_ERQ_ERQ14_MASK   (0x4000U)
 
#define DMA_ERQ_ERQ14_SHIFT   (14U)
 
#define DMA_ERQ_ERQ14(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERQ_ERQ14_SHIFT)) & DMA_ERQ_ERQ14_MASK)
 
#define DMA_ERQ_ERQ15_MASK   (0x8000U)
 
#define DMA_ERQ_ERQ15_SHIFT   (15U)
 
#define DMA_ERQ_ERQ15(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERQ_ERQ15_SHIFT)) & DMA_ERQ_ERQ15_MASK)
 
EEI - Enable Error Interrupt Register
#define DMA_EEI_EEI0_MASK   (0x1U)
 
#define DMA_EEI_EEI0_SHIFT   (0U)
 
#define DMA_EEI_EEI0(x)   (((uint32_t)(((uint32_t)(x)) << DMA_EEI_EEI0_SHIFT)) & DMA_EEI_EEI0_MASK)
 
#define DMA_EEI_EEI1_MASK   (0x2U)
 
#define DMA_EEI_EEI1_SHIFT   (1U)
 
#define DMA_EEI_EEI1(x)   (((uint32_t)(((uint32_t)(x)) << DMA_EEI_EEI1_SHIFT)) & DMA_EEI_EEI1_MASK)
 
#define DMA_EEI_EEI2_MASK   (0x4U)
 
#define DMA_EEI_EEI2_SHIFT   (2U)
 
#define DMA_EEI_EEI2(x)   (((uint32_t)(((uint32_t)(x)) << DMA_EEI_EEI2_SHIFT)) & DMA_EEI_EEI2_MASK)
 
#define DMA_EEI_EEI3_MASK   (0x8U)
 
#define DMA_EEI_EEI3_SHIFT   (3U)
 
#define DMA_EEI_EEI3(x)   (((uint32_t)(((uint32_t)(x)) << DMA_EEI_EEI3_SHIFT)) & DMA_EEI_EEI3_MASK)
 
#define DMA_EEI_EEI4_MASK   (0x10U)
 
#define DMA_EEI_EEI4_SHIFT   (4U)
 
#define DMA_EEI_EEI4(x)   (((uint32_t)(((uint32_t)(x)) << DMA_EEI_EEI4_SHIFT)) & DMA_EEI_EEI4_MASK)
 
#define DMA_EEI_EEI5_MASK   (0x20U)
 
#define DMA_EEI_EEI5_SHIFT   (5U)
 
#define DMA_EEI_EEI5(x)   (((uint32_t)(((uint32_t)(x)) << DMA_EEI_EEI5_SHIFT)) & DMA_EEI_EEI5_MASK)
 
#define DMA_EEI_EEI6_MASK   (0x40U)
 
#define DMA_EEI_EEI6_SHIFT   (6U)
 
#define DMA_EEI_EEI6(x)   (((uint32_t)(((uint32_t)(x)) << DMA_EEI_EEI6_SHIFT)) & DMA_EEI_EEI6_MASK)
 
#define DMA_EEI_EEI7_MASK   (0x80U)
 
#define DMA_EEI_EEI7_SHIFT   (7U)
 
#define DMA_EEI_EEI7(x)   (((uint32_t)(((uint32_t)(x)) << DMA_EEI_EEI7_SHIFT)) & DMA_EEI_EEI7_MASK)
 
#define DMA_EEI_EEI8_MASK   (0x100U)
 
#define DMA_EEI_EEI8_SHIFT   (8U)
 
#define DMA_EEI_EEI8(x)   (((uint32_t)(((uint32_t)(x)) << DMA_EEI_EEI8_SHIFT)) & DMA_EEI_EEI8_MASK)
 
#define DMA_EEI_EEI9_MASK   (0x200U)
 
#define DMA_EEI_EEI9_SHIFT   (9U)
 
#define DMA_EEI_EEI9(x)   (((uint32_t)(((uint32_t)(x)) << DMA_EEI_EEI9_SHIFT)) & DMA_EEI_EEI9_MASK)
 
#define DMA_EEI_EEI10_MASK   (0x400U)
 
#define DMA_EEI_EEI10_SHIFT   (10U)
 
#define DMA_EEI_EEI10(x)   (((uint32_t)(((uint32_t)(x)) << DMA_EEI_EEI10_SHIFT)) & DMA_EEI_EEI10_MASK)
 
#define DMA_EEI_EEI11_MASK   (0x800U)
 
#define DMA_EEI_EEI11_SHIFT   (11U)
 
#define DMA_EEI_EEI11(x)   (((uint32_t)(((uint32_t)(x)) << DMA_EEI_EEI11_SHIFT)) & DMA_EEI_EEI11_MASK)
 
#define DMA_EEI_EEI12_MASK   (0x1000U)
 
#define DMA_EEI_EEI12_SHIFT   (12U)
 
#define DMA_EEI_EEI12(x)   (((uint32_t)(((uint32_t)(x)) << DMA_EEI_EEI12_SHIFT)) & DMA_EEI_EEI12_MASK)
 
#define DMA_EEI_EEI13_MASK   (0x2000U)
 
#define DMA_EEI_EEI13_SHIFT   (13U)
 
#define DMA_EEI_EEI13(x)   (((uint32_t)(((uint32_t)(x)) << DMA_EEI_EEI13_SHIFT)) & DMA_EEI_EEI13_MASK)
 
#define DMA_EEI_EEI14_MASK   (0x4000U)
 
#define DMA_EEI_EEI14_SHIFT   (14U)
 
#define DMA_EEI_EEI14(x)   (((uint32_t)(((uint32_t)(x)) << DMA_EEI_EEI14_SHIFT)) & DMA_EEI_EEI14_MASK)
 
#define DMA_EEI_EEI15_MASK   (0x8000U)
 
#define DMA_EEI_EEI15_SHIFT   (15U)
 
#define DMA_EEI_EEI15(x)   (((uint32_t)(((uint32_t)(x)) << DMA_EEI_EEI15_SHIFT)) & DMA_EEI_EEI15_MASK)
 
CEEI - Clear Enable Error Interrupt Register
#define DMA_CEEI_CEEI_MASK   (0xFU)
 
#define DMA_CEEI_CEEI_SHIFT   (0U)
 
#define DMA_CEEI_CEEI(x)   (((uint8_t)(((uint8_t)(x)) << DMA_CEEI_CEEI_SHIFT)) & DMA_CEEI_CEEI_MASK)
 
#define DMA_CEEI_CAEE_MASK   (0x40U)
 
#define DMA_CEEI_CAEE_SHIFT   (6U)
 
#define DMA_CEEI_CAEE(x)   (((uint8_t)(((uint8_t)(x)) << DMA_CEEI_CAEE_SHIFT)) & DMA_CEEI_CAEE_MASK)
 
#define DMA_CEEI_NOP_MASK   (0x80U)
 
#define DMA_CEEI_NOP_SHIFT   (7U)
 
#define DMA_CEEI_NOP(x)   (((uint8_t)(((uint8_t)(x)) << DMA_CEEI_NOP_SHIFT)) & DMA_CEEI_NOP_MASK)
 
SEEI - Set Enable Error Interrupt Register
#define DMA_SEEI_SEEI_MASK   (0xFU)
 
#define DMA_SEEI_SEEI_SHIFT   (0U)
 
#define DMA_SEEI_SEEI(x)   (((uint8_t)(((uint8_t)(x)) << DMA_SEEI_SEEI_SHIFT)) & DMA_SEEI_SEEI_MASK)
 
#define DMA_SEEI_SAEE_MASK   (0x40U)
 
#define DMA_SEEI_SAEE_SHIFT   (6U)
 
#define DMA_SEEI_SAEE(x)   (((uint8_t)(((uint8_t)(x)) << DMA_SEEI_SAEE_SHIFT)) & DMA_SEEI_SAEE_MASK)
 
#define DMA_SEEI_NOP_MASK   (0x80U)
 
#define DMA_SEEI_NOP_SHIFT   (7U)
 
#define DMA_SEEI_NOP(x)   (((uint8_t)(((uint8_t)(x)) << DMA_SEEI_NOP_SHIFT)) & DMA_SEEI_NOP_MASK)
 
CERQ - Clear Enable Request Register
#define DMA_CERQ_CERQ_MASK   (0xFU)
 
#define DMA_CERQ_CERQ_SHIFT   (0U)
 
#define DMA_CERQ_CERQ(x)   (((uint8_t)(((uint8_t)(x)) << DMA_CERQ_CERQ_SHIFT)) & DMA_CERQ_CERQ_MASK)
 
#define DMA_CERQ_CAER_MASK   (0x40U)
 
#define DMA_CERQ_CAER_SHIFT   (6U)
 
#define DMA_CERQ_CAER(x)   (((uint8_t)(((uint8_t)(x)) << DMA_CERQ_CAER_SHIFT)) & DMA_CERQ_CAER_MASK)
 
#define DMA_CERQ_NOP_MASK   (0x80U)
 
#define DMA_CERQ_NOP_SHIFT   (7U)
 
#define DMA_CERQ_NOP(x)   (((uint8_t)(((uint8_t)(x)) << DMA_CERQ_NOP_SHIFT)) & DMA_CERQ_NOP_MASK)
 
SERQ - Set Enable Request Register
#define DMA_SERQ_SERQ_MASK   (0xFU)
 
#define DMA_SERQ_SERQ_SHIFT   (0U)
 
#define DMA_SERQ_SERQ(x)   (((uint8_t)(((uint8_t)(x)) << DMA_SERQ_SERQ_SHIFT)) & DMA_SERQ_SERQ_MASK)
 
#define DMA_SERQ_SAER_MASK   (0x40U)
 
#define DMA_SERQ_SAER_SHIFT   (6U)
 
#define DMA_SERQ_SAER(x)   (((uint8_t)(((uint8_t)(x)) << DMA_SERQ_SAER_SHIFT)) & DMA_SERQ_SAER_MASK)
 
#define DMA_SERQ_NOP_MASK   (0x80U)
 
#define DMA_SERQ_NOP_SHIFT   (7U)
 
#define DMA_SERQ_NOP(x)   (((uint8_t)(((uint8_t)(x)) << DMA_SERQ_NOP_SHIFT)) & DMA_SERQ_NOP_MASK)
 
CDNE - Clear DONE Status Bit Register
#define DMA_CDNE_CDNE_MASK   (0xFU)
 
#define DMA_CDNE_CDNE_SHIFT   (0U)
 
#define DMA_CDNE_CDNE(x)   (((uint8_t)(((uint8_t)(x)) << DMA_CDNE_CDNE_SHIFT)) & DMA_CDNE_CDNE_MASK)
 
#define DMA_CDNE_CADN_MASK   (0x40U)
 
#define DMA_CDNE_CADN_SHIFT   (6U)
 
#define DMA_CDNE_CADN(x)   (((uint8_t)(((uint8_t)(x)) << DMA_CDNE_CADN_SHIFT)) & DMA_CDNE_CADN_MASK)
 
#define DMA_CDNE_NOP_MASK   (0x80U)
 
#define DMA_CDNE_NOP_SHIFT   (7U)
 
#define DMA_CDNE_NOP(x)   (((uint8_t)(((uint8_t)(x)) << DMA_CDNE_NOP_SHIFT)) & DMA_CDNE_NOP_MASK)
 
SSRT - Set START Bit Register
#define DMA_SSRT_SSRT_MASK   (0xFU)
 
#define DMA_SSRT_SSRT_SHIFT   (0U)
 
#define DMA_SSRT_SSRT(x)   (((uint8_t)(((uint8_t)(x)) << DMA_SSRT_SSRT_SHIFT)) & DMA_SSRT_SSRT_MASK)
 
#define DMA_SSRT_SAST_MASK   (0x40U)
 
#define DMA_SSRT_SAST_SHIFT   (6U)
 
#define DMA_SSRT_SAST(x)   (((uint8_t)(((uint8_t)(x)) << DMA_SSRT_SAST_SHIFT)) & DMA_SSRT_SAST_MASK)
 
#define DMA_SSRT_NOP_MASK   (0x80U)
 
#define DMA_SSRT_NOP_SHIFT   (7U)
 
#define DMA_SSRT_NOP(x)   (((uint8_t)(((uint8_t)(x)) << DMA_SSRT_NOP_SHIFT)) & DMA_SSRT_NOP_MASK)
 
CERR - Clear Error Register
#define DMA_CERR_CERR_MASK   (0xFU)
 
#define DMA_CERR_CERR_SHIFT   (0U)
 
#define DMA_CERR_CERR(x)   (((uint8_t)(((uint8_t)(x)) << DMA_CERR_CERR_SHIFT)) & DMA_CERR_CERR_MASK)
 
#define DMA_CERR_CAEI_MASK   (0x40U)
 
#define DMA_CERR_CAEI_SHIFT   (6U)
 
#define DMA_CERR_CAEI(x)   (((uint8_t)(((uint8_t)(x)) << DMA_CERR_CAEI_SHIFT)) & DMA_CERR_CAEI_MASK)
 
#define DMA_CERR_NOP_MASK   (0x80U)
 
#define DMA_CERR_NOP_SHIFT   (7U)
 
#define DMA_CERR_NOP(x)   (((uint8_t)(((uint8_t)(x)) << DMA_CERR_NOP_SHIFT)) & DMA_CERR_NOP_MASK)
 
CINT - Clear Interrupt Request Register
#define DMA_CINT_CINT_MASK   (0xFU)
 
#define DMA_CINT_CINT_SHIFT   (0U)
 
#define DMA_CINT_CINT(x)   (((uint8_t)(((uint8_t)(x)) << DMA_CINT_CINT_SHIFT)) & DMA_CINT_CINT_MASK)
 
#define DMA_CINT_CAIR_MASK   (0x40U)
 
#define DMA_CINT_CAIR_SHIFT   (6U)
 
#define DMA_CINT_CAIR(x)   (((uint8_t)(((uint8_t)(x)) << DMA_CINT_CAIR_SHIFT)) & DMA_CINT_CAIR_MASK)
 
#define DMA_CINT_NOP_MASK   (0x80U)
 
#define DMA_CINT_NOP_SHIFT   (7U)
 
#define DMA_CINT_NOP(x)   (((uint8_t)(((uint8_t)(x)) << DMA_CINT_NOP_SHIFT)) & DMA_CINT_NOP_MASK)
 
INT - Interrupt Request Register
#define DMA_INT_INT0_MASK   (0x1U)
 
#define DMA_INT_INT0_SHIFT   (0U)
 
#define DMA_INT_INT0(x)   (((uint32_t)(((uint32_t)(x)) << DMA_INT_INT0_SHIFT)) & DMA_INT_INT0_MASK)
 
#define DMA_INT_INT1_MASK   (0x2U)
 
#define DMA_INT_INT1_SHIFT   (1U)
 
#define DMA_INT_INT1(x)   (((uint32_t)(((uint32_t)(x)) << DMA_INT_INT1_SHIFT)) & DMA_INT_INT1_MASK)
 
#define DMA_INT_INT2_MASK   (0x4U)
 
#define DMA_INT_INT2_SHIFT   (2U)
 
#define DMA_INT_INT2(x)   (((uint32_t)(((uint32_t)(x)) << DMA_INT_INT2_SHIFT)) & DMA_INT_INT2_MASK)
 
#define DMA_INT_INT3_MASK   (0x8U)
 
#define DMA_INT_INT3_SHIFT   (3U)
 
#define DMA_INT_INT3(x)   (((uint32_t)(((uint32_t)(x)) << DMA_INT_INT3_SHIFT)) & DMA_INT_INT3_MASK)
 
#define DMA_INT_INT4_MASK   (0x10U)
 
#define DMA_INT_INT4_SHIFT   (4U)
 
#define DMA_INT_INT4(x)   (((uint32_t)(((uint32_t)(x)) << DMA_INT_INT4_SHIFT)) & DMA_INT_INT4_MASK)
 
#define DMA_INT_INT5_MASK   (0x20U)
 
#define DMA_INT_INT5_SHIFT   (5U)
 
#define DMA_INT_INT5(x)   (((uint32_t)(((uint32_t)(x)) << DMA_INT_INT5_SHIFT)) & DMA_INT_INT5_MASK)
 
#define DMA_INT_INT6_MASK   (0x40U)
 
#define DMA_INT_INT6_SHIFT   (6U)
 
#define DMA_INT_INT6(x)   (((uint32_t)(((uint32_t)(x)) << DMA_INT_INT6_SHIFT)) & DMA_INT_INT6_MASK)
 
#define DMA_INT_INT7_MASK   (0x80U)
 
#define DMA_INT_INT7_SHIFT   (7U)
 
#define DMA_INT_INT7(x)   (((uint32_t)(((uint32_t)(x)) << DMA_INT_INT7_SHIFT)) & DMA_INT_INT7_MASK)
 
#define DMA_INT_INT8_MASK   (0x100U)
 
#define DMA_INT_INT8_SHIFT   (8U)
 
#define DMA_INT_INT8(x)   (((uint32_t)(((uint32_t)(x)) << DMA_INT_INT8_SHIFT)) & DMA_INT_INT8_MASK)
 
#define DMA_INT_INT9_MASK   (0x200U)
 
#define DMA_INT_INT9_SHIFT   (9U)
 
#define DMA_INT_INT9(x)   (((uint32_t)(((uint32_t)(x)) << DMA_INT_INT9_SHIFT)) & DMA_INT_INT9_MASK)
 
#define DMA_INT_INT10_MASK   (0x400U)
 
#define DMA_INT_INT10_SHIFT   (10U)
 
#define DMA_INT_INT10(x)   (((uint32_t)(((uint32_t)(x)) << DMA_INT_INT10_SHIFT)) & DMA_INT_INT10_MASK)
 
#define DMA_INT_INT11_MASK   (0x800U)
 
#define DMA_INT_INT11_SHIFT   (11U)
 
#define DMA_INT_INT11(x)   (((uint32_t)(((uint32_t)(x)) << DMA_INT_INT11_SHIFT)) & DMA_INT_INT11_MASK)
 
#define DMA_INT_INT12_MASK   (0x1000U)
 
#define DMA_INT_INT12_SHIFT   (12U)
 
#define DMA_INT_INT12(x)   (((uint32_t)(((uint32_t)(x)) << DMA_INT_INT12_SHIFT)) & DMA_INT_INT12_MASK)
 
#define DMA_INT_INT13_MASK   (0x2000U)
 
#define DMA_INT_INT13_SHIFT   (13U)
 
#define DMA_INT_INT13(x)   (((uint32_t)(((uint32_t)(x)) << DMA_INT_INT13_SHIFT)) & DMA_INT_INT13_MASK)
 
#define DMA_INT_INT14_MASK   (0x4000U)
 
#define DMA_INT_INT14_SHIFT   (14U)
 
#define DMA_INT_INT14(x)   (((uint32_t)(((uint32_t)(x)) << DMA_INT_INT14_SHIFT)) & DMA_INT_INT14_MASK)
 
#define DMA_INT_INT15_MASK   (0x8000U)
 
#define DMA_INT_INT15_SHIFT   (15U)
 
#define DMA_INT_INT15(x)   (((uint32_t)(((uint32_t)(x)) << DMA_INT_INT15_SHIFT)) & DMA_INT_INT15_MASK)
 
ERR - Error Register
#define DMA_ERR_ERR0_MASK   (0x1U)
 
#define DMA_ERR_ERR0_SHIFT   (0U)
 
#define DMA_ERR_ERR0(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERR_ERR0_SHIFT)) & DMA_ERR_ERR0_MASK)
 
#define DMA_ERR_ERR1_MASK   (0x2U)
 
#define DMA_ERR_ERR1_SHIFT   (1U)
 
#define DMA_ERR_ERR1(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERR_ERR1_SHIFT)) & DMA_ERR_ERR1_MASK)
 
#define DMA_ERR_ERR2_MASK   (0x4U)
 
#define DMA_ERR_ERR2_SHIFT   (2U)
 
#define DMA_ERR_ERR2(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERR_ERR2_SHIFT)) & DMA_ERR_ERR2_MASK)
 
#define DMA_ERR_ERR3_MASK   (0x8U)
 
#define DMA_ERR_ERR3_SHIFT   (3U)
 
#define DMA_ERR_ERR3(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERR_ERR3_SHIFT)) & DMA_ERR_ERR3_MASK)
 
#define DMA_ERR_ERR4_MASK   (0x10U)
 
#define DMA_ERR_ERR4_SHIFT   (4U)
 
#define DMA_ERR_ERR4(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERR_ERR4_SHIFT)) & DMA_ERR_ERR4_MASK)
 
#define DMA_ERR_ERR5_MASK   (0x20U)
 
#define DMA_ERR_ERR5_SHIFT   (5U)
 
#define DMA_ERR_ERR5(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERR_ERR5_SHIFT)) & DMA_ERR_ERR5_MASK)
 
#define DMA_ERR_ERR6_MASK   (0x40U)
 
#define DMA_ERR_ERR6_SHIFT   (6U)
 
#define DMA_ERR_ERR6(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERR_ERR6_SHIFT)) & DMA_ERR_ERR6_MASK)
 
#define DMA_ERR_ERR7_MASK   (0x80U)
 
#define DMA_ERR_ERR7_SHIFT   (7U)
 
#define DMA_ERR_ERR7(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERR_ERR7_SHIFT)) & DMA_ERR_ERR7_MASK)
 
#define DMA_ERR_ERR8_MASK   (0x100U)
 
#define DMA_ERR_ERR8_SHIFT   (8U)
 
#define DMA_ERR_ERR8(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERR_ERR8_SHIFT)) & DMA_ERR_ERR8_MASK)
 
#define DMA_ERR_ERR9_MASK   (0x200U)
 
#define DMA_ERR_ERR9_SHIFT   (9U)
 
#define DMA_ERR_ERR9(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERR_ERR9_SHIFT)) & DMA_ERR_ERR9_MASK)
 
#define DMA_ERR_ERR10_MASK   (0x400U)
 
#define DMA_ERR_ERR10_SHIFT   (10U)
 
#define DMA_ERR_ERR10(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERR_ERR10_SHIFT)) & DMA_ERR_ERR10_MASK)
 
#define DMA_ERR_ERR11_MASK   (0x800U)
 
#define DMA_ERR_ERR11_SHIFT   (11U)
 
#define DMA_ERR_ERR11(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERR_ERR11_SHIFT)) & DMA_ERR_ERR11_MASK)
 
#define DMA_ERR_ERR12_MASK   (0x1000U)
 
#define DMA_ERR_ERR12_SHIFT   (12U)
 
#define DMA_ERR_ERR12(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERR_ERR12_SHIFT)) & DMA_ERR_ERR12_MASK)
 
#define DMA_ERR_ERR13_MASK   (0x2000U)
 
#define DMA_ERR_ERR13_SHIFT   (13U)
 
#define DMA_ERR_ERR13(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERR_ERR13_SHIFT)) & DMA_ERR_ERR13_MASK)
 
#define DMA_ERR_ERR14_MASK   (0x4000U)
 
#define DMA_ERR_ERR14_SHIFT   (14U)
 
#define DMA_ERR_ERR14(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERR_ERR14_SHIFT)) & DMA_ERR_ERR14_MASK)
 
#define DMA_ERR_ERR15_MASK   (0x8000U)
 
#define DMA_ERR_ERR15_SHIFT   (15U)
 
#define DMA_ERR_ERR15(x)   (((uint32_t)(((uint32_t)(x)) << DMA_ERR_ERR15_SHIFT)) & DMA_ERR_ERR15_MASK)
 
HRS - Hardware Request Status Register
#define DMA_HRS_HRS0_MASK   (0x1U)
 
#define DMA_HRS_HRS0_SHIFT   (0U)
 
#define DMA_HRS_HRS0(x)   (((uint32_t)(((uint32_t)(x)) << DMA_HRS_HRS0_SHIFT)) & DMA_HRS_HRS0_MASK)
 
#define DMA_HRS_HRS1_MASK   (0x2U)
 
#define DMA_HRS_HRS1_SHIFT   (1U)
 
#define DMA_HRS_HRS1(x)   (((uint32_t)(((uint32_t)(x)) << DMA_HRS_HRS1_SHIFT)) & DMA_HRS_HRS1_MASK)
 
#define DMA_HRS_HRS2_MASK   (0x4U)
 
#define DMA_HRS_HRS2_SHIFT   (2U)
 
#define DMA_HRS_HRS2(x)   (((uint32_t)(((uint32_t)(x)) << DMA_HRS_HRS2_SHIFT)) & DMA_HRS_HRS2_MASK)
 
#define DMA_HRS_HRS3_MASK   (0x8U)
 
#define DMA_HRS_HRS3_SHIFT   (3U)
 
#define DMA_HRS_HRS3(x)   (((uint32_t)(((uint32_t)(x)) << DMA_HRS_HRS3_SHIFT)) & DMA_HRS_HRS3_MASK)
 
#define DMA_HRS_HRS4_MASK   (0x10U)
 
#define DMA_HRS_HRS4_SHIFT   (4U)
 
#define DMA_HRS_HRS4(x)   (((uint32_t)(((uint32_t)(x)) << DMA_HRS_HRS4_SHIFT)) & DMA_HRS_HRS4_MASK)
 
#define DMA_HRS_HRS5_MASK   (0x20U)
 
#define DMA_HRS_HRS5_SHIFT   (5U)
 
#define DMA_HRS_HRS5(x)   (((uint32_t)(((uint32_t)(x)) << DMA_HRS_HRS5_SHIFT)) & DMA_HRS_HRS5_MASK)
 
#define DMA_HRS_HRS6_MASK   (0x40U)
 
#define DMA_HRS_HRS6_SHIFT   (6U)
 
#define DMA_HRS_HRS6(x)   (((uint32_t)(((uint32_t)(x)) << DMA_HRS_HRS6_SHIFT)) & DMA_HRS_HRS6_MASK)
 
#define DMA_HRS_HRS7_MASK   (0x80U)
 
#define DMA_HRS_HRS7_SHIFT   (7U)
 
#define DMA_HRS_HRS7(x)   (((uint32_t)(((uint32_t)(x)) << DMA_HRS_HRS7_SHIFT)) & DMA_HRS_HRS7_MASK)
 
#define DMA_HRS_HRS8_MASK   (0x100U)
 
#define DMA_HRS_HRS8_SHIFT   (8U)
 
#define DMA_HRS_HRS8(x)   (((uint32_t)(((uint32_t)(x)) << DMA_HRS_HRS8_SHIFT)) & DMA_HRS_HRS8_MASK)
 
#define DMA_HRS_HRS9_MASK   (0x200U)
 
#define DMA_HRS_HRS9_SHIFT   (9U)
 
#define DMA_HRS_HRS9(x)   (((uint32_t)(((uint32_t)(x)) << DMA_HRS_HRS9_SHIFT)) & DMA_HRS_HRS9_MASK)
 
#define DMA_HRS_HRS10_MASK   (0x400U)
 
#define DMA_HRS_HRS10_SHIFT   (10U)
 
#define DMA_HRS_HRS10(x)   (((uint32_t)(((uint32_t)(x)) << DMA_HRS_HRS10_SHIFT)) & DMA_HRS_HRS10_MASK)
 
#define DMA_HRS_HRS11_MASK   (0x800U)
 
#define DMA_HRS_HRS11_SHIFT   (11U)
 
#define DMA_HRS_HRS11(x)   (((uint32_t)(((uint32_t)(x)) << DMA_HRS_HRS11_SHIFT)) & DMA_HRS_HRS11_MASK)
 
#define DMA_HRS_HRS12_MASK   (0x1000U)
 
#define DMA_HRS_HRS12_SHIFT   (12U)
 
#define DMA_HRS_HRS12(x)   (((uint32_t)(((uint32_t)(x)) << DMA_HRS_HRS12_SHIFT)) & DMA_HRS_HRS12_MASK)
 
#define DMA_HRS_HRS13_MASK   (0x2000U)
 
#define DMA_HRS_HRS13_SHIFT   (13U)
 
#define DMA_HRS_HRS13(x)   (((uint32_t)(((uint32_t)(x)) << DMA_HRS_HRS13_SHIFT)) & DMA_HRS_HRS13_MASK)
 
#define DMA_HRS_HRS14_MASK   (0x4000U)
 
#define DMA_HRS_HRS14_SHIFT   (14U)
 
#define DMA_HRS_HRS14(x)   (((uint32_t)(((uint32_t)(x)) << DMA_HRS_HRS14_SHIFT)) & DMA_HRS_HRS14_MASK)
 
#define DMA_HRS_HRS15_MASK   (0x8000U)
 
#define DMA_HRS_HRS15_SHIFT   (15U)
 
#define DMA_HRS_HRS15(x)   (((uint32_t)(((uint32_t)(x)) << DMA_HRS_HRS15_SHIFT)) & DMA_HRS_HRS15_MASK)
 
DCHPRI3 - Channel n Priority Register
#define DMA_DCHPRI3_CHPRI_MASK   (0xFU)
 
#define DMA_DCHPRI3_CHPRI_SHIFT   (0U)
 
#define DMA_DCHPRI3_CHPRI(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI3_CHPRI_SHIFT)) & DMA_DCHPRI3_CHPRI_MASK)
 
#define DMA_DCHPRI3_DPA_MASK   (0x40U)
 
#define DMA_DCHPRI3_DPA_SHIFT   (6U)
 
#define DMA_DCHPRI3_DPA(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI3_DPA_SHIFT)) & DMA_DCHPRI3_DPA_MASK)
 
#define DMA_DCHPRI3_ECP_MASK   (0x80U)
 
#define DMA_DCHPRI3_ECP_SHIFT   (7U)
 
#define DMA_DCHPRI3_ECP(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI3_ECP_SHIFT)) & DMA_DCHPRI3_ECP_MASK)
 
DCHPRI2 - Channel n Priority Register
#define DMA_DCHPRI2_CHPRI_MASK   (0xFU)
 
#define DMA_DCHPRI2_CHPRI_SHIFT   (0U)
 
#define DMA_DCHPRI2_CHPRI(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI2_CHPRI_SHIFT)) & DMA_DCHPRI2_CHPRI_MASK)
 
#define DMA_DCHPRI2_DPA_MASK   (0x40U)
 
#define DMA_DCHPRI2_DPA_SHIFT   (6U)
 
#define DMA_DCHPRI2_DPA(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI2_DPA_SHIFT)) & DMA_DCHPRI2_DPA_MASK)
 
#define DMA_DCHPRI2_ECP_MASK   (0x80U)
 
#define DMA_DCHPRI2_ECP_SHIFT   (7U)
 
#define DMA_DCHPRI2_ECP(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI2_ECP_SHIFT)) & DMA_DCHPRI2_ECP_MASK)
 
DCHPRI1 - Channel n Priority Register
#define DMA_DCHPRI1_CHPRI_MASK   (0xFU)
 
#define DMA_DCHPRI1_CHPRI_SHIFT   (0U)
 
#define DMA_DCHPRI1_CHPRI(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI1_CHPRI_SHIFT)) & DMA_DCHPRI1_CHPRI_MASK)
 
#define DMA_DCHPRI1_DPA_MASK   (0x40U)
 
#define DMA_DCHPRI1_DPA_SHIFT   (6U)
 
#define DMA_DCHPRI1_DPA(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI1_DPA_SHIFT)) & DMA_DCHPRI1_DPA_MASK)
 
#define DMA_DCHPRI1_ECP_MASK   (0x80U)
 
#define DMA_DCHPRI1_ECP_SHIFT   (7U)
 
#define DMA_DCHPRI1_ECP(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI1_ECP_SHIFT)) & DMA_DCHPRI1_ECP_MASK)
 
DCHPRI0 - Channel n Priority Register
#define DMA_DCHPRI0_CHPRI_MASK   (0xFU)
 
#define DMA_DCHPRI0_CHPRI_SHIFT   (0U)
 
#define DMA_DCHPRI0_CHPRI(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI0_CHPRI_SHIFT)) & DMA_DCHPRI0_CHPRI_MASK)
 
#define DMA_DCHPRI0_DPA_MASK   (0x40U)
 
#define DMA_DCHPRI0_DPA_SHIFT   (6U)
 
#define DMA_DCHPRI0_DPA(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI0_DPA_SHIFT)) & DMA_DCHPRI0_DPA_MASK)
 
#define DMA_DCHPRI0_ECP_MASK   (0x80U)
 
#define DMA_DCHPRI0_ECP_SHIFT   (7U)
 
#define DMA_DCHPRI0_ECP(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI0_ECP_SHIFT)) & DMA_DCHPRI0_ECP_MASK)
 
DCHPRI7 - Channel n Priority Register
#define DMA_DCHPRI7_CHPRI_MASK   (0xFU)
 
#define DMA_DCHPRI7_CHPRI_SHIFT   (0U)
 
#define DMA_DCHPRI7_CHPRI(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI7_CHPRI_SHIFT)) & DMA_DCHPRI7_CHPRI_MASK)
 
#define DMA_DCHPRI7_DPA_MASK   (0x40U)
 
#define DMA_DCHPRI7_DPA_SHIFT   (6U)
 
#define DMA_DCHPRI7_DPA(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI7_DPA_SHIFT)) & DMA_DCHPRI7_DPA_MASK)
 
#define DMA_DCHPRI7_ECP_MASK   (0x80U)
 
#define DMA_DCHPRI7_ECP_SHIFT   (7U)
 
#define DMA_DCHPRI7_ECP(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI7_ECP_SHIFT)) & DMA_DCHPRI7_ECP_MASK)
 
DCHPRI6 - Channel n Priority Register
#define DMA_DCHPRI6_CHPRI_MASK   (0xFU)
 
#define DMA_DCHPRI6_CHPRI_SHIFT   (0U)
 
#define DMA_DCHPRI6_CHPRI(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI6_CHPRI_SHIFT)) & DMA_DCHPRI6_CHPRI_MASK)
 
#define DMA_DCHPRI6_DPA_MASK   (0x40U)
 
#define DMA_DCHPRI6_DPA_SHIFT   (6U)
 
#define DMA_DCHPRI6_DPA(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI6_DPA_SHIFT)) & DMA_DCHPRI6_DPA_MASK)
 
#define DMA_DCHPRI6_ECP_MASK   (0x80U)
 
#define DMA_DCHPRI6_ECP_SHIFT   (7U)
 
#define DMA_DCHPRI6_ECP(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI6_ECP_SHIFT)) & DMA_DCHPRI6_ECP_MASK)
 
DCHPRI5 - Channel n Priority Register
#define DMA_DCHPRI5_CHPRI_MASK   (0xFU)
 
#define DMA_DCHPRI5_CHPRI_SHIFT   (0U)
 
#define DMA_DCHPRI5_CHPRI(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI5_CHPRI_SHIFT)) & DMA_DCHPRI5_CHPRI_MASK)
 
#define DMA_DCHPRI5_DPA_MASK   (0x40U)
 
#define DMA_DCHPRI5_DPA_SHIFT   (6U)
 
#define DMA_DCHPRI5_DPA(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI5_DPA_SHIFT)) & DMA_DCHPRI5_DPA_MASK)
 
#define DMA_DCHPRI5_ECP_MASK   (0x80U)
 
#define DMA_DCHPRI5_ECP_SHIFT   (7U)
 
#define DMA_DCHPRI5_ECP(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI5_ECP_SHIFT)) & DMA_DCHPRI5_ECP_MASK)
 
DCHPRI4 - Channel n Priority Register
#define DMA_DCHPRI4_CHPRI_MASK   (0xFU)
 
#define DMA_DCHPRI4_CHPRI_SHIFT   (0U)
 
#define DMA_DCHPRI4_CHPRI(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI4_CHPRI_SHIFT)) & DMA_DCHPRI4_CHPRI_MASK)
 
#define DMA_DCHPRI4_DPA_MASK   (0x40U)
 
#define DMA_DCHPRI4_DPA_SHIFT   (6U)
 
#define DMA_DCHPRI4_DPA(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI4_DPA_SHIFT)) & DMA_DCHPRI4_DPA_MASK)
 
#define DMA_DCHPRI4_ECP_MASK   (0x80U)
 
#define DMA_DCHPRI4_ECP_SHIFT   (7U)
 
#define DMA_DCHPRI4_ECP(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI4_ECP_SHIFT)) & DMA_DCHPRI4_ECP_MASK)
 
DCHPRI11 - Channel n Priority Register
#define DMA_DCHPRI11_CHPRI_MASK   (0xFU)
 
#define DMA_DCHPRI11_CHPRI_SHIFT   (0U)
 
#define DMA_DCHPRI11_CHPRI(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI11_CHPRI_SHIFT)) & DMA_DCHPRI11_CHPRI_MASK)
 
#define DMA_DCHPRI11_DPA_MASK   (0x40U)
 
#define DMA_DCHPRI11_DPA_SHIFT   (6U)
 
#define DMA_DCHPRI11_DPA(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI11_DPA_SHIFT)) & DMA_DCHPRI11_DPA_MASK)
 
#define DMA_DCHPRI11_ECP_MASK   (0x80U)
 
#define DMA_DCHPRI11_ECP_SHIFT   (7U)
 
#define DMA_DCHPRI11_ECP(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI11_ECP_SHIFT)) & DMA_DCHPRI11_ECP_MASK)
 
DCHPRI10 - Channel n Priority Register
#define DMA_DCHPRI10_CHPRI_MASK   (0xFU)
 
#define DMA_DCHPRI10_CHPRI_SHIFT   (0U)
 
#define DMA_DCHPRI10_CHPRI(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI10_CHPRI_SHIFT)) & DMA_DCHPRI10_CHPRI_MASK)
 
#define DMA_DCHPRI10_DPA_MASK   (0x40U)
 
#define DMA_DCHPRI10_DPA_SHIFT   (6U)
 
#define DMA_DCHPRI10_DPA(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI10_DPA_SHIFT)) & DMA_DCHPRI10_DPA_MASK)
 
#define DMA_DCHPRI10_ECP_MASK   (0x80U)
 
#define DMA_DCHPRI10_ECP_SHIFT   (7U)
 
#define DMA_DCHPRI10_ECP(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI10_ECP_SHIFT)) & DMA_DCHPRI10_ECP_MASK)
 
DCHPRI9 - Channel n Priority Register
#define DMA_DCHPRI9_CHPRI_MASK   (0xFU)
 
#define DMA_DCHPRI9_CHPRI_SHIFT   (0U)
 
#define DMA_DCHPRI9_CHPRI(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI9_CHPRI_SHIFT)) & DMA_DCHPRI9_CHPRI_MASK)
 
#define DMA_DCHPRI9_DPA_MASK   (0x40U)
 
#define DMA_DCHPRI9_DPA_SHIFT   (6U)
 
#define DMA_DCHPRI9_DPA(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI9_DPA_SHIFT)) & DMA_DCHPRI9_DPA_MASK)
 
#define DMA_DCHPRI9_ECP_MASK   (0x80U)
 
#define DMA_DCHPRI9_ECP_SHIFT   (7U)
 
#define DMA_DCHPRI9_ECP(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI9_ECP_SHIFT)) & DMA_DCHPRI9_ECP_MASK)
 
DCHPRI8 - Channel n Priority Register
#define DMA_DCHPRI8_CHPRI_MASK   (0xFU)
 
#define DMA_DCHPRI8_CHPRI_SHIFT   (0U)
 
#define DMA_DCHPRI8_CHPRI(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI8_CHPRI_SHIFT)) & DMA_DCHPRI8_CHPRI_MASK)
 
#define DMA_DCHPRI8_DPA_MASK   (0x40U)
 
#define DMA_DCHPRI8_DPA_SHIFT   (6U)
 
#define DMA_DCHPRI8_DPA(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI8_DPA_SHIFT)) & DMA_DCHPRI8_DPA_MASK)
 
#define DMA_DCHPRI8_ECP_MASK   (0x80U)
 
#define DMA_DCHPRI8_ECP_SHIFT   (7U)
 
#define DMA_DCHPRI8_ECP(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI8_ECP_SHIFT)) & DMA_DCHPRI8_ECP_MASK)
 
DCHPRI15 - Channel n Priority Register
#define DMA_DCHPRI15_CHPRI_MASK   (0xFU)
 
#define DMA_DCHPRI15_CHPRI_SHIFT   (0U)
 
#define DMA_DCHPRI15_CHPRI(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI15_CHPRI_SHIFT)) & DMA_DCHPRI15_CHPRI_MASK)
 
#define DMA_DCHPRI15_DPA_MASK   (0x40U)
 
#define DMA_DCHPRI15_DPA_SHIFT   (6U)
 
#define DMA_DCHPRI15_DPA(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI15_DPA_SHIFT)) & DMA_DCHPRI15_DPA_MASK)
 
#define DMA_DCHPRI15_ECP_MASK   (0x80U)
 
#define DMA_DCHPRI15_ECP_SHIFT   (7U)
 
#define DMA_DCHPRI15_ECP(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI15_ECP_SHIFT)) & DMA_DCHPRI15_ECP_MASK)
 
DCHPRI14 - Channel n Priority Register
#define DMA_DCHPRI14_CHPRI_MASK   (0xFU)
 
#define DMA_DCHPRI14_CHPRI_SHIFT   (0U)
 
#define DMA_DCHPRI14_CHPRI(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI14_CHPRI_SHIFT)) & DMA_DCHPRI14_CHPRI_MASK)
 
#define DMA_DCHPRI14_DPA_MASK   (0x40U)
 
#define DMA_DCHPRI14_DPA_SHIFT   (6U)
 
#define DMA_DCHPRI14_DPA(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI14_DPA_SHIFT)) & DMA_DCHPRI14_DPA_MASK)
 
#define DMA_DCHPRI14_ECP_MASK   (0x80U)
 
#define DMA_DCHPRI14_ECP_SHIFT   (7U)
 
#define DMA_DCHPRI14_ECP(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI14_ECP_SHIFT)) & DMA_DCHPRI14_ECP_MASK)
 
DCHPRI13 - Channel n Priority Register
#define DMA_DCHPRI13_CHPRI_MASK   (0xFU)
 
#define DMA_DCHPRI13_CHPRI_SHIFT   (0U)
 
#define DMA_DCHPRI13_CHPRI(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI13_CHPRI_SHIFT)) & DMA_DCHPRI13_CHPRI_MASK)
 
#define DMA_DCHPRI13_DPA_MASK   (0x40U)
 
#define DMA_DCHPRI13_DPA_SHIFT   (6U)
 
#define DMA_DCHPRI13_DPA(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI13_DPA_SHIFT)) & DMA_DCHPRI13_DPA_MASK)
 
#define DMA_DCHPRI13_ECP_MASK   (0x80U)
 
#define DMA_DCHPRI13_ECP_SHIFT   (7U)
 
#define DMA_DCHPRI13_ECP(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI13_ECP_SHIFT)) & DMA_DCHPRI13_ECP_MASK)
 
DCHPRI12 - Channel n Priority Register
#define DMA_DCHPRI12_CHPRI_MASK   (0xFU)
 
#define DMA_DCHPRI12_CHPRI_SHIFT   (0U)
 
#define DMA_DCHPRI12_CHPRI(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI12_CHPRI_SHIFT)) & DMA_DCHPRI12_CHPRI_MASK)
 
#define DMA_DCHPRI12_DPA_MASK   (0x40U)
 
#define DMA_DCHPRI12_DPA_SHIFT   (6U)
 
#define DMA_DCHPRI12_DPA(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI12_DPA_SHIFT)) & DMA_DCHPRI12_DPA_MASK)
 
#define DMA_DCHPRI12_ECP_MASK   (0x80U)
 
#define DMA_DCHPRI12_ECP_SHIFT   (7U)
 
#define DMA_DCHPRI12_ECP(x)   (((uint8_t)(((uint8_t)(x)) << DMA_DCHPRI12_ECP_SHIFT)) & DMA_DCHPRI12_ECP_MASK)
 
SADDR - TCD Source Address
#define DMA_SADDR_SADDR_MASK   (0xFFFFFFFFU)
 
#define DMA_SADDR_SADDR_SHIFT   (0U)
 
#define DMA_SADDR_SADDR(x)   (((uint32_t)(((uint32_t)(x)) << DMA_SADDR_SADDR_SHIFT)) & DMA_SADDR_SADDR_MASK)
 
#define DMA_SADDR_COUNT   (16U)
 
SOFF - TCD Signed Source Address Offset
#define DMA_SOFF_SOFF_MASK   (0xFFFFU)
 
#define DMA_SOFF_SOFF_SHIFT   (0U)
 
#define DMA_SOFF_SOFF(x)   (((uint16_t)(((uint16_t)(x)) << DMA_SOFF_SOFF_SHIFT)) & DMA_SOFF_SOFF_MASK)
 
#define DMA_SOFF_COUNT   (16U)
 
ATTR - TCD Transfer Attributes
#define DMA_ATTR_DSIZE_MASK   (0x7U)
 
#define DMA_ATTR_DSIZE_SHIFT   (0U)
 
#define DMA_ATTR_DSIZE(x)   (((uint16_t)(((uint16_t)(x)) << DMA_ATTR_DSIZE_SHIFT)) & DMA_ATTR_DSIZE_MASK)
 
#define DMA_ATTR_DMOD_MASK   (0xF8U)
 
#define DMA_ATTR_DMOD_SHIFT   (3U)
 
#define DMA_ATTR_DMOD(x)   (((uint16_t)(((uint16_t)(x)) << DMA_ATTR_DMOD_SHIFT)) & DMA_ATTR_DMOD_MASK)
 
#define DMA_ATTR_SSIZE_MASK   (0x700U)
 
#define DMA_ATTR_SSIZE_SHIFT   (8U)
 
#define DMA_ATTR_SSIZE(x)   (((uint16_t)(((uint16_t)(x)) << DMA_ATTR_SSIZE_SHIFT)) & DMA_ATTR_SSIZE_MASK)
 
#define DMA_ATTR_SMOD_MASK   (0xF800U)
 
#define DMA_ATTR_SMOD_SHIFT   (11U)
 
#define DMA_ATTR_SMOD(x)   (((uint16_t)(((uint16_t)(x)) << DMA_ATTR_SMOD_SHIFT)) & DMA_ATTR_SMOD_MASK)
 
#define DMA_ATTR_COUNT   (16U)
 
NBYTES_MLNO - TCD Minor Byte Count (Minor Loop Disabled)
#define DMA_NBYTES_MLNO_NBYTES_MASK   (0xFFFFFFFFU)
 
#define DMA_NBYTES_MLNO_NBYTES_SHIFT   (0U)
 
#define DMA_NBYTES_MLNO_NBYTES(x)   (((uint32_t)(((uint32_t)(x)) << DMA_NBYTES_MLNO_NBYTES_SHIFT)) & DMA_NBYTES_MLNO_NBYTES_MASK)
 
#define DMA_NBYTES_MLNO_COUNT   (16U)
 
NBYTES_MLOFFNO - TCD Signed Minor Loop Offset (Minor Loop Enabled and Offset Disabled)
#define DMA_NBYTES_MLOFFNO_NBYTES_MASK   (0x3FFFFFFFU)
 
#define DMA_NBYTES_MLOFFNO_NBYTES_SHIFT   (0U)
 
#define DMA_NBYTES_MLOFFNO_NBYTES(x)   (((uint32_t)(((uint32_t)(x)) << DMA_NBYTES_MLOFFNO_NBYTES_SHIFT)) & DMA_NBYTES_MLOFFNO_NBYTES_MASK)
 
#define DMA_NBYTES_MLOFFNO_DMLOE_MASK   (0x40000000U)
 
#define DMA_NBYTES_MLOFFNO_DMLOE_SHIFT   (30U)
 
#define DMA_NBYTES_MLOFFNO_DMLOE(x)   (((uint32_t)(((uint32_t)(x)) << DMA_NBYTES_MLOFFNO_DMLOE_SHIFT)) & DMA_NBYTES_MLOFFNO_DMLOE_MASK)
 
#define DMA_NBYTES_MLOFFNO_SMLOE_MASK   (0x80000000U)
 
#define DMA_NBYTES_MLOFFNO_SMLOE_SHIFT   (31U)
 
#define DMA_NBYTES_MLOFFNO_SMLOE(x)   (((uint32_t)(((uint32_t)(x)) << DMA_NBYTES_MLOFFNO_SMLOE_SHIFT)) & DMA_NBYTES_MLOFFNO_SMLOE_MASK)
 
#define DMA_NBYTES_MLOFFNO_COUNT   (16U)
 
NBYTES_MLOFFYES - TCD Signed Minor Loop Offset (Minor Loop and Offset Enabled)
#define DMA_NBYTES_MLOFFYES_NBYTES_MASK   (0x3FFU)
 
#define DMA_NBYTES_MLOFFYES_NBYTES_SHIFT   (0U)
 
#define DMA_NBYTES_MLOFFYES_NBYTES(x)   (((uint32_t)(((uint32_t)(x)) << DMA_NBYTES_MLOFFYES_NBYTES_SHIFT)) & DMA_NBYTES_MLOFFYES_NBYTES_MASK)
 
#define DMA_NBYTES_MLOFFYES_MLOFF_MASK   (0x3FFFFC00U)
 
#define DMA_NBYTES_MLOFFYES_MLOFF_SHIFT   (10U)
 
#define DMA_NBYTES_MLOFFYES_MLOFF(x)   (((uint32_t)(((uint32_t)(x)) << DMA_NBYTES_MLOFFYES_MLOFF_SHIFT)) & DMA_NBYTES_MLOFFYES_MLOFF_MASK)
 
#define DMA_NBYTES_MLOFFYES_DMLOE_MASK   (0x40000000U)
 
#define DMA_NBYTES_MLOFFYES_DMLOE_SHIFT   (30U)
 
#define DMA_NBYTES_MLOFFYES_DMLOE(x)   (((uint32_t)(((uint32_t)(x)) << DMA_NBYTES_MLOFFYES_DMLOE_SHIFT)) & DMA_NBYTES_MLOFFYES_DMLOE_MASK)
 
#define DMA_NBYTES_MLOFFYES_SMLOE_MASK   (0x80000000U)
 
#define DMA_NBYTES_MLOFFYES_SMLOE_SHIFT   (31U)
 
#define DMA_NBYTES_MLOFFYES_SMLOE(x)   (((uint32_t)(((uint32_t)(x)) << DMA_NBYTES_MLOFFYES_SMLOE_SHIFT)) & DMA_NBYTES_MLOFFYES_SMLOE_MASK)
 
#define DMA_NBYTES_MLOFFYES_COUNT   (16U)
 
SLAST - TCD Last Source Address Adjustment
#define DMA_SLAST_SLAST_MASK   (0xFFFFFFFFU)
 
#define DMA_SLAST_SLAST_SHIFT   (0U)
 
#define DMA_SLAST_SLAST(x)   (((uint32_t)(((uint32_t)(x)) << DMA_SLAST_SLAST_SHIFT)) & DMA_SLAST_SLAST_MASK)
 
#define DMA_SLAST_COUNT   (16U)
 
DADDR - TCD Destination Address
#define DMA_DADDR_DADDR_MASK   (0xFFFFFFFFU)
 
#define DMA_DADDR_DADDR_SHIFT   (0U)
 
#define DMA_DADDR_DADDR(x)   (((uint32_t)(((uint32_t)(x)) << DMA_DADDR_DADDR_SHIFT)) & DMA_DADDR_DADDR_MASK)
 
#define DMA_DADDR_COUNT   (16U)
 
DOFF - TCD Signed Destination Address Offset
#define DMA_DOFF_DOFF_MASK   (0xFFFFU)
 
#define DMA_DOFF_DOFF_SHIFT   (0U)
 
#define DMA_DOFF_DOFF(x)   (((uint16_t)(((uint16_t)(x)) << DMA_DOFF_DOFF_SHIFT)) & DMA_DOFF_DOFF_MASK)
 
#define DMA_DOFF_COUNT   (16U)
 
CITER_ELINKNO - TCD Current Minor Loop Link, Major Loop Count (Channel Linking Disabled)
#define DMA_CITER_ELINKNO_CITER_MASK   (0x7FFFU)
 
#define DMA_CITER_ELINKNO_CITER_SHIFT   (0U)
 
#define DMA_CITER_ELINKNO_CITER(x)   (((uint16_t)(((uint16_t)(x)) << DMA_CITER_ELINKNO_CITER_SHIFT)) & DMA_CITER_ELINKNO_CITER_MASK)
 
#define DMA_CITER_ELINKNO_ELINK_MASK   (0x8000U)
 
#define DMA_CITER_ELINKNO_ELINK_SHIFT   (15U)
 
#define DMA_CITER_ELINKNO_ELINK(x)   (((uint16_t)(((uint16_t)(x)) << DMA_CITER_ELINKNO_ELINK_SHIFT)) & DMA_CITER_ELINKNO_ELINK_MASK)
 
#define DMA_CITER_ELINKNO_COUNT   (16U)
 
CITER_ELINKYES - TCD Current Minor Loop Link, Major Loop Count (Channel Linking Enabled)
#define DMA_CITER_ELINKYES_CITER_MASK   (0x1FFU)
 
#define DMA_CITER_ELINKYES_CITER_SHIFT   (0U)
 
#define DMA_CITER_ELINKYES_CITER(x)   (((uint16_t)(((uint16_t)(x)) << DMA_CITER_ELINKYES_CITER_SHIFT)) & DMA_CITER_ELINKYES_CITER_MASK)
 
#define DMA_CITER_ELINKYES_LINKCH_MASK   (0x1E00U)
 
#define DMA_CITER_ELINKYES_LINKCH_SHIFT   (9U)
 
#define DMA_CITER_ELINKYES_LINKCH(x)   (((uint16_t)(((uint16_t)(x)) << DMA_CITER_ELINKYES_LINKCH_SHIFT)) & DMA_CITER_ELINKYES_LINKCH_MASK)
 
#define DMA_CITER_ELINKYES_ELINK_MASK   (0x8000U)
 
#define DMA_CITER_ELINKYES_ELINK_SHIFT   (15U)
 
#define DMA_CITER_ELINKYES_ELINK(x)   (((uint16_t)(((uint16_t)(x)) << DMA_CITER_ELINKYES_ELINK_SHIFT)) & DMA_CITER_ELINKYES_ELINK_MASK)
 
#define DMA_CITER_ELINKYES_COUNT   (16U)
 
DLAST_SGA - TCD Last Destination Address Adjustment/Scatter Gather Address
#define DMA_DLAST_SGA_DLASTSGA_MASK   (0xFFFFFFFFU)
 
#define DMA_DLAST_SGA_DLASTSGA_SHIFT   (0U)
 
#define DMA_DLAST_SGA_DLASTSGA(x)   (((uint32_t)(((uint32_t)(x)) << DMA_DLAST_SGA_DLASTSGA_SHIFT)) & DMA_DLAST_SGA_DLASTSGA_MASK)
 
#define DMA_DLAST_SGA_COUNT   (16U)
 
CSR - TCD Control and Status
#define DMA_CSR_START_MASK   (0x1U)
 
#define DMA_CSR_START_SHIFT   (0U)
 
#define DMA_CSR_START(x)   (((uint16_t)(((uint16_t)(x)) << DMA_CSR_START_SHIFT)) & DMA_CSR_START_MASK)
 
#define DMA_CSR_INTMAJOR_MASK   (0x2U)
 
#define DMA_CSR_INTMAJOR_SHIFT   (1U)
 
#define DMA_CSR_INTMAJOR(x)   (((uint16_t)(((uint16_t)(x)) << DMA_CSR_INTMAJOR_SHIFT)) & DMA_CSR_INTMAJOR_MASK)
 
#define DMA_CSR_INTHALF_MASK   (0x4U)
 
#define DMA_CSR_INTHALF_SHIFT   (2U)
 
#define DMA_CSR_INTHALF(x)   (((uint16_t)(((uint16_t)(x)) << DMA_CSR_INTHALF_SHIFT)) & DMA_CSR_INTHALF_MASK)
 
#define DMA_CSR_DREQ_MASK   (0x8U)
 
#define DMA_CSR_DREQ_SHIFT   (3U)
 
#define DMA_CSR_DREQ(x)   (((uint16_t)(((uint16_t)(x)) << DMA_CSR_DREQ_SHIFT)) & DMA_CSR_DREQ_MASK)
 
#define DMA_CSR_ESG_MASK   (0x10U)
 
#define DMA_CSR_ESG_SHIFT   (4U)
 
#define DMA_CSR_ESG(x)   (((uint16_t)(((uint16_t)(x)) << DMA_CSR_ESG_SHIFT)) & DMA_CSR_ESG_MASK)
 
#define DMA_CSR_MAJORELINK_MASK   (0x20U)
 
#define DMA_CSR_MAJORELINK_SHIFT   (5U)
 
#define DMA_CSR_MAJORELINK(x)   (((uint16_t)(((uint16_t)(x)) << DMA_CSR_MAJORELINK_SHIFT)) & DMA_CSR_MAJORELINK_MASK)
 
#define DMA_CSR_ACTIVE_MASK   (0x40U)
 
#define DMA_CSR_ACTIVE_SHIFT   (6U)
 
#define DMA_CSR_ACTIVE(x)   (((uint16_t)(((uint16_t)(x)) << DMA_CSR_ACTIVE_SHIFT)) & DMA_CSR_ACTIVE_MASK)
 
#define DMA_CSR_DONE_MASK   (0x80U)
 
#define DMA_CSR_DONE_SHIFT   (7U)
 
#define DMA_CSR_DONE(x)   (((uint16_t)(((uint16_t)(x)) << DMA_CSR_DONE_SHIFT)) & DMA_CSR_DONE_MASK)
 
#define DMA_CSR_MAJORLINKCH_MASK   (0xF00U)
 
#define DMA_CSR_MAJORLINKCH_SHIFT   (8U)
 
#define DMA_CSR_MAJORLINKCH(x)   (((uint16_t)(((uint16_t)(x)) << DMA_CSR_MAJORLINKCH_SHIFT)) & DMA_CSR_MAJORLINKCH_MASK)
 
#define DMA_CSR_BWC_MASK   (0xC000U)
 
#define DMA_CSR_BWC_SHIFT   (14U)
 
#define DMA_CSR_BWC(x)   (((uint16_t)(((uint16_t)(x)) << DMA_CSR_BWC_SHIFT)) & DMA_CSR_BWC_MASK)
 
#define DMA_CSR_COUNT   (16U)
 
BITER_ELINKNO - TCD Beginning Minor Loop Link, Major Loop Count (Channel Linking Disabled)
#define DMA_BITER_ELINKNO_BITER_MASK   (0x7FFFU)
 
#define DMA_BITER_ELINKNO_BITER_SHIFT   (0U)
 
#define DMA_BITER_ELINKNO_BITER(x)   (((uint16_t)(((uint16_t)(x)) << DMA_BITER_ELINKNO_BITER_SHIFT)) & DMA_BITER_ELINKNO_BITER_MASK)
 
#define DMA_BITER_ELINKNO_ELINK_MASK   (0x8000U)
 
#define DMA_BITER_ELINKNO_ELINK_SHIFT   (15U)
 
#define DMA_BITER_ELINKNO_ELINK(x)   (((uint16_t)(((uint16_t)(x)) << DMA_BITER_ELINKNO_ELINK_SHIFT)) & DMA_BITER_ELINKNO_ELINK_MASK)
 
#define DMA_BITER_ELINKNO_COUNT   (16U)
 
BITER_ELINKYES - TCD Beginning Minor Loop Link, Major Loop Count (Channel Linking Enabled)
#define DMA_BITER_ELINKYES_BITER_MASK   (0x1FFU)
 
#define DMA_BITER_ELINKYES_BITER_SHIFT   (0U)
 
#define DMA_BITER_ELINKYES_BITER(x)   (((uint16_t)(((uint16_t)(x)) << DMA_BITER_ELINKYES_BITER_SHIFT)) & DMA_BITER_ELINKYES_BITER_MASK)
 
#define DMA_BITER_ELINKYES_LINKCH_MASK   (0x1E00U)
 
#define DMA_BITER_ELINKYES_LINKCH_SHIFT   (9U)
 
#define DMA_BITER_ELINKYES_LINKCH(x)   (((uint16_t)(((uint16_t)(x)) << DMA_BITER_ELINKYES_LINKCH_SHIFT)) & DMA_BITER_ELINKYES_LINKCH_MASK)
 
#define DMA_BITER_ELINKYES_ELINK_MASK   (0x8000U)
 
#define DMA_BITER_ELINKYES_ELINK_SHIFT   (15U)
 
#define DMA_BITER_ELINKYES_ELINK(x)   (((uint16_t)(((uint16_t)(x)) << DMA_BITER_ELINKYES_ELINK_SHIFT)) & DMA_BITER_ELINKYES_ELINK_MASK)
 
#define DMA_BITER_ELINKYES_COUNT   (16U)
 
CHCFG - Channel Configuration register
#define DMAMUX_CHCFG_SOURCE_MASK   (0x3FU)
 
#define DMAMUX_CHCFG_SOURCE_SHIFT   (0U)
 
#define DMAMUX_CHCFG_SOURCE(x)   (((uint8_t)(((uint8_t)(x)) << DMAMUX_CHCFG_SOURCE_SHIFT)) & DMAMUX_CHCFG_SOURCE_MASK)
 
#define DMAMUX_CHCFG_TRIG_MASK   (0x40U)
 
#define DMAMUX_CHCFG_TRIG_SHIFT   (6U)
 
#define DMAMUX_CHCFG_TRIG(x)   (((uint8_t)(((uint8_t)(x)) << DMAMUX_CHCFG_TRIG_SHIFT)) & DMAMUX_CHCFG_TRIG_MASK)
 
#define DMAMUX_CHCFG_ENBL_MASK   (0x80U)
 
#define DMAMUX_CHCFG_ENBL_SHIFT   (7U)
 
#define DMAMUX_CHCFG_ENBL(x)   (((uint8_t)(((uint8_t)(x)) << DMAMUX_CHCFG_ENBL_SHIFT)) & DMAMUX_CHCFG_ENBL_MASK)
 
#define DMAMUX_CHCFG_COUNT   (16U)
 
EIR - Interrupt Event Register
#define ENET_EIR_TS_TIMER_MASK   (0x8000U)
 
#define ENET_EIR_TS_TIMER_SHIFT   (15U)
 
#define ENET_EIR_TS_TIMER(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIR_TS_TIMER_SHIFT)) & ENET_EIR_TS_TIMER_MASK)
 
#define ENET_EIR_TS_AVAIL_MASK   (0x10000U)
 
#define ENET_EIR_TS_AVAIL_SHIFT   (16U)
 
#define ENET_EIR_TS_AVAIL(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIR_TS_AVAIL_SHIFT)) & ENET_EIR_TS_AVAIL_MASK)
 
#define ENET_EIR_WAKEUP_MASK   (0x20000U)
 
#define ENET_EIR_WAKEUP_SHIFT   (17U)
 
#define ENET_EIR_WAKEUP(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIR_WAKEUP_SHIFT)) & ENET_EIR_WAKEUP_MASK)
 
#define ENET_EIR_PLR_MASK   (0x40000U)
 
#define ENET_EIR_PLR_SHIFT   (18U)
 
#define ENET_EIR_PLR(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIR_PLR_SHIFT)) & ENET_EIR_PLR_MASK)
 
#define ENET_EIR_UN_MASK   (0x80000U)
 
#define ENET_EIR_UN_SHIFT   (19U)
 
#define ENET_EIR_UN(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIR_UN_SHIFT)) & ENET_EIR_UN_MASK)
 
#define ENET_EIR_RL_MASK   (0x100000U)
 
#define ENET_EIR_RL_SHIFT   (20U)
 
#define ENET_EIR_RL(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIR_RL_SHIFT)) & ENET_EIR_RL_MASK)
 
#define ENET_EIR_LC_MASK   (0x200000U)
 
#define ENET_EIR_LC_SHIFT   (21U)
 
#define ENET_EIR_LC(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIR_LC_SHIFT)) & ENET_EIR_LC_MASK)
 
#define ENET_EIR_EBERR_MASK   (0x400000U)
 
#define ENET_EIR_EBERR_SHIFT   (22U)
 
#define ENET_EIR_EBERR(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIR_EBERR_SHIFT)) & ENET_EIR_EBERR_MASK)
 
#define ENET_EIR_MII_MASK   (0x800000U)
 
#define ENET_EIR_MII_SHIFT   (23U)
 
#define ENET_EIR_MII(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIR_MII_SHIFT)) & ENET_EIR_MII_MASK)
 
#define ENET_EIR_RXB_MASK   (0x1000000U)
 
#define ENET_EIR_RXB_SHIFT   (24U)
 
#define ENET_EIR_RXB(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIR_RXB_SHIFT)) & ENET_EIR_RXB_MASK)
 
#define ENET_EIR_RXF_MASK   (0x2000000U)
 
#define ENET_EIR_RXF_SHIFT   (25U)
 
#define ENET_EIR_RXF(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIR_RXF_SHIFT)) & ENET_EIR_RXF_MASK)
 
#define ENET_EIR_TXB_MASK   (0x4000000U)
 
#define ENET_EIR_TXB_SHIFT   (26U)
 
#define ENET_EIR_TXB(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIR_TXB_SHIFT)) & ENET_EIR_TXB_MASK)
 
#define ENET_EIR_TXF_MASK   (0x8000000U)
 
#define ENET_EIR_TXF_SHIFT   (27U)
 
#define ENET_EIR_TXF(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIR_TXF_SHIFT)) & ENET_EIR_TXF_MASK)
 
#define ENET_EIR_GRA_MASK   (0x10000000U)
 
#define ENET_EIR_GRA_SHIFT   (28U)
 
#define ENET_EIR_GRA(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIR_GRA_SHIFT)) & ENET_EIR_GRA_MASK)
 
#define ENET_EIR_BABT_MASK   (0x20000000U)
 
#define ENET_EIR_BABT_SHIFT   (29U)
 
#define ENET_EIR_BABT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIR_BABT_SHIFT)) & ENET_EIR_BABT_MASK)
 
#define ENET_EIR_BABR_MASK   (0x40000000U)
 
#define ENET_EIR_BABR_SHIFT   (30U)
 
#define ENET_EIR_BABR(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIR_BABR_SHIFT)) & ENET_EIR_BABR_MASK)
 
EIMR - Interrupt Mask Register
#define ENET_EIMR_TS_TIMER_MASK   (0x8000U)
 
#define ENET_EIMR_TS_TIMER_SHIFT   (15U)
 
#define ENET_EIMR_TS_TIMER(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIMR_TS_TIMER_SHIFT)) & ENET_EIMR_TS_TIMER_MASK)
 
#define ENET_EIMR_TS_AVAIL_MASK   (0x10000U)
 
#define ENET_EIMR_TS_AVAIL_SHIFT   (16U)
 
#define ENET_EIMR_TS_AVAIL(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIMR_TS_AVAIL_SHIFT)) & ENET_EIMR_TS_AVAIL_MASK)
 
#define ENET_EIMR_WAKEUP_MASK   (0x20000U)
 
#define ENET_EIMR_WAKEUP_SHIFT   (17U)
 
#define ENET_EIMR_WAKEUP(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIMR_WAKEUP_SHIFT)) & ENET_EIMR_WAKEUP_MASK)
 
#define ENET_EIMR_PLR_MASK   (0x40000U)
 
#define ENET_EIMR_PLR_SHIFT   (18U)
 
#define ENET_EIMR_PLR(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIMR_PLR_SHIFT)) & ENET_EIMR_PLR_MASK)
 
#define ENET_EIMR_UN_MASK   (0x80000U)
 
#define ENET_EIMR_UN_SHIFT   (19U)
 
#define ENET_EIMR_UN(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIMR_UN_SHIFT)) & ENET_EIMR_UN_MASK)
 
#define ENET_EIMR_RL_MASK   (0x100000U)
 
#define ENET_EIMR_RL_SHIFT   (20U)
 
#define ENET_EIMR_RL(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIMR_RL_SHIFT)) & ENET_EIMR_RL_MASK)
 
#define ENET_EIMR_LC_MASK   (0x200000U)
 
#define ENET_EIMR_LC_SHIFT   (21U)
 
#define ENET_EIMR_LC(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIMR_LC_SHIFT)) & ENET_EIMR_LC_MASK)
 
#define ENET_EIMR_EBERR_MASK   (0x400000U)
 
#define ENET_EIMR_EBERR_SHIFT   (22U)
 
#define ENET_EIMR_EBERR(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIMR_EBERR_SHIFT)) & ENET_EIMR_EBERR_MASK)
 
#define ENET_EIMR_MII_MASK   (0x800000U)
 
#define ENET_EIMR_MII_SHIFT   (23U)
 
#define ENET_EIMR_MII(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIMR_MII_SHIFT)) & ENET_EIMR_MII_MASK)
 
#define ENET_EIMR_RXB_MASK   (0x1000000U)
 
#define ENET_EIMR_RXB_SHIFT   (24U)
 
#define ENET_EIMR_RXB(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIMR_RXB_SHIFT)) & ENET_EIMR_RXB_MASK)
 
#define ENET_EIMR_RXF_MASK   (0x2000000U)
 
#define ENET_EIMR_RXF_SHIFT   (25U)
 
#define ENET_EIMR_RXF(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIMR_RXF_SHIFT)) & ENET_EIMR_RXF_MASK)
 
#define ENET_EIMR_TXB_MASK   (0x4000000U)
 
#define ENET_EIMR_TXB_SHIFT   (26U)
 
#define ENET_EIMR_TXB(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIMR_TXB_SHIFT)) & ENET_EIMR_TXB_MASK)
 
#define ENET_EIMR_TXF_MASK   (0x8000000U)
 
#define ENET_EIMR_TXF_SHIFT   (27U)
 
#define ENET_EIMR_TXF(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIMR_TXF_SHIFT)) & ENET_EIMR_TXF_MASK)
 
#define ENET_EIMR_GRA_MASK   (0x10000000U)
 
#define ENET_EIMR_GRA_SHIFT   (28U)
 
#define ENET_EIMR_GRA(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIMR_GRA_SHIFT)) & ENET_EIMR_GRA_MASK)
 
#define ENET_EIMR_BABT_MASK   (0x20000000U)
 
#define ENET_EIMR_BABT_SHIFT   (29U)
 
#define ENET_EIMR_BABT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIMR_BABT_SHIFT)) & ENET_EIMR_BABT_MASK)
 
#define ENET_EIMR_BABR_MASK   (0x40000000U)
 
#define ENET_EIMR_BABR_SHIFT   (30U)
 
#define ENET_EIMR_BABR(x)   (((uint32_t)(((uint32_t)(x)) << ENET_EIMR_BABR_SHIFT)) & ENET_EIMR_BABR_MASK)
 
RDAR - Receive Descriptor Active Register
#define ENET_RDAR_RDAR_MASK   (0x1000000U)
 
#define ENET_RDAR_RDAR_SHIFT   (24U)
 
#define ENET_RDAR_RDAR(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RDAR_RDAR_SHIFT)) & ENET_RDAR_RDAR_MASK)
 
TDAR - Transmit Descriptor Active Register
#define ENET_TDAR_TDAR_MASK   (0x1000000U)
 
#define ENET_TDAR_TDAR_SHIFT   (24U)
 
#define ENET_TDAR_TDAR(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TDAR_TDAR_SHIFT)) & ENET_TDAR_TDAR_MASK)
 
ECR - Ethernet Control Register
#define ENET_ECR_RESET_MASK   (0x1U)
 
#define ENET_ECR_RESET_SHIFT   (0U)
 
#define ENET_ECR_RESET(x)   (((uint32_t)(((uint32_t)(x)) << ENET_ECR_RESET_SHIFT)) & ENET_ECR_RESET_MASK)
 
#define ENET_ECR_ETHEREN_MASK   (0x2U)
 
#define ENET_ECR_ETHEREN_SHIFT   (1U)
 
#define ENET_ECR_ETHEREN(x)   (((uint32_t)(((uint32_t)(x)) << ENET_ECR_ETHEREN_SHIFT)) & ENET_ECR_ETHEREN_MASK)
 
#define ENET_ECR_MAGICEN_MASK   (0x4U)
 
#define ENET_ECR_MAGICEN_SHIFT   (2U)
 
#define ENET_ECR_MAGICEN(x)   (((uint32_t)(((uint32_t)(x)) << ENET_ECR_MAGICEN_SHIFT)) & ENET_ECR_MAGICEN_MASK)
 
#define ENET_ECR_SLEEP_MASK   (0x8U)
 
#define ENET_ECR_SLEEP_SHIFT   (3U)
 
#define ENET_ECR_SLEEP(x)   (((uint32_t)(((uint32_t)(x)) << ENET_ECR_SLEEP_SHIFT)) & ENET_ECR_SLEEP_MASK)
 
#define ENET_ECR_EN1588_MASK   (0x10U)
 
#define ENET_ECR_EN1588_SHIFT   (4U)
 
#define ENET_ECR_EN1588(x)   (((uint32_t)(((uint32_t)(x)) << ENET_ECR_EN1588_SHIFT)) & ENET_ECR_EN1588_MASK)
 
#define ENET_ECR_DBGEN_MASK   (0x40U)
 
#define ENET_ECR_DBGEN_SHIFT   (6U)
 
#define ENET_ECR_DBGEN(x)   (((uint32_t)(((uint32_t)(x)) << ENET_ECR_DBGEN_SHIFT)) & ENET_ECR_DBGEN_MASK)
 
#define ENET_ECR_STOPEN_MASK   (0x80U)
 
#define ENET_ECR_STOPEN_SHIFT   (7U)
 
#define ENET_ECR_STOPEN(x)   (((uint32_t)(((uint32_t)(x)) << ENET_ECR_STOPEN_SHIFT)) & ENET_ECR_STOPEN_MASK)
 
#define ENET_ECR_DBSWP_MASK   (0x100U)
 
#define ENET_ECR_DBSWP_SHIFT   (8U)
 
#define ENET_ECR_DBSWP(x)   (((uint32_t)(((uint32_t)(x)) << ENET_ECR_DBSWP_SHIFT)) & ENET_ECR_DBSWP_MASK)
 
MMFR - MII Management Frame Register
#define ENET_MMFR_DATA_MASK   (0xFFFFU)
 
#define ENET_MMFR_DATA_SHIFT   (0U)
 
#define ENET_MMFR_DATA(x)   (((uint32_t)(((uint32_t)(x)) << ENET_MMFR_DATA_SHIFT)) & ENET_MMFR_DATA_MASK)
 
#define ENET_MMFR_TA_MASK   (0x30000U)
 
#define ENET_MMFR_TA_SHIFT   (16U)
 
#define ENET_MMFR_TA(x)   (((uint32_t)(((uint32_t)(x)) << ENET_MMFR_TA_SHIFT)) & ENET_MMFR_TA_MASK)
 
#define ENET_MMFR_RA_MASK   (0x7C0000U)
 
#define ENET_MMFR_RA_SHIFT   (18U)
 
#define ENET_MMFR_RA(x)   (((uint32_t)(((uint32_t)(x)) << ENET_MMFR_RA_SHIFT)) & ENET_MMFR_RA_MASK)
 
#define ENET_MMFR_PA_MASK   (0xF800000U)
 
#define ENET_MMFR_PA_SHIFT   (23U)
 
#define ENET_MMFR_PA(x)   (((uint32_t)(((uint32_t)(x)) << ENET_MMFR_PA_SHIFT)) & ENET_MMFR_PA_MASK)
 
#define ENET_MMFR_OP_MASK   (0x30000000U)
 
#define ENET_MMFR_OP_SHIFT   (28U)
 
#define ENET_MMFR_OP(x)   (((uint32_t)(((uint32_t)(x)) << ENET_MMFR_OP_SHIFT)) & ENET_MMFR_OP_MASK)
 
#define ENET_MMFR_ST_MASK   (0xC0000000U)
 
#define ENET_MMFR_ST_SHIFT   (30U)
 
#define ENET_MMFR_ST(x)   (((uint32_t)(((uint32_t)(x)) << ENET_MMFR_ST_SHIFT)) & ENET_MMFR_ST_MASK)
 
MSCR - MII Speed Control Register
#define ENET_MSCR_MII_SPEED_MASK   (0x7EU)
 
#define ENET_MSCR_MII_SPEED_SHIFT   (1U)
 
#define ENET_MSCR_MII_SPEED(x)   (((uint32_t)(((uint32_t)(x)) << ENET_MSCR_MII_SPEED_SHIFT)) & ENET_MSCR_MII_SPEED_MASK)
 
#define ENET_MSCR_DIS_PRE_MASK   (0x80U)
 
#define ENET_MSCR_DIS_PRE_SHIFT   (7U)
 
#define ENET_MSCR_DIS_PRE(x)   (((uint32_t)(((uint32_t)(x)) << ENET_MSCR_DIS_PRE_SHIFT)) & ENET_MSCR_DIS_PRE_MASK)
 
#define ENET_MSCR_HOLDTIME_MASK   (0x700U)
 
#define ENET_MSCR_HOLDTIME_SHIFT   (8U)
 
#define ENET_MSCR_HOLDTIME(x)   (((uint32_t)(((uint32_t)(x)) << ENET_MSCR_HOLDTIME_SHIFT)) & ENET_MSCR_HOLDTIME_MASK)
 
MIBC - MIB Control Register
#define ENET_MIBC_MIB_CLEAR_MASK   (0x20000000U)
 
#define ENET_MIBC_MIB_CLEAR_SHIFT   (29U)
 
#define ENET_MIBC_MIB_CLEAR(x)   (((uint32_t)(((uint32_t)(x)) << ENET_MIBC_MIB_CLEAR_SHIFT)) & ENET_MIBC_MIB_CLEAR_MASK)
 
#define ENET_MIBC_MIB_IDLE_MASK   (0x40000000U)
 
#define ENET_MIBC_MIB_IDLE_SHIFT   (30U)
 
#define ENET_MIBC_MIB_IDLE(x)   (((uint32_t)(((uint32_t)(x)) << ENET_MIBC_MIB_IDLE_SHIFT)) & ENET_MIBC_MIB_IDLE_MASK)
 
#define ENET_MIBC_MIB_DIS_MASK   (0x80000000U)
 
#define ENET_MIBC_MIB_DIS_SHIFT   (31U)
 
#define ENET_MIBC_MIB_DIS(x)   (((uint32_t)(((uint32_t)(x)) << ENET_MIBC_MIB_DIS_SHIFT)) & ENET_MIBC_MIB_DIS_MASK)
 
RCR - Receive Control Register
#define ENET_RCR_LOOP_MASK   (0x1U)
 
#define ENET_RCR_LOOP_SHIFT   (0U)
 
#define ENET_RCR_LOOP(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RCR_LOOP_SHIFT)) & ENET_RCR_LOOP_MASK)
 
#define ENET_RCR_DRT_MASK   (0x2U)
 
#define ENET_RCR_DRT_SHIFT   (1U)
 
#define ENET_RCR_DRT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RCR_DRT_SHIFT)) & ENET_RCR_DRT_MASK)
 
#define ENET_RCR_MII_MODE_MASK   (0x4U)
 
#define ENET_RCR_MII_MODE_SHIFT   (2U)
 
#define ENET_RCR_MII_MODE(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RCR_MII_MODE_SHIFT)) & ENET_RCR_MII_MODE_MASK)
 
#define ENET_RCR_PROM_MASK   (0x8U)
 
#define ENET_RCR_PROM_SHIFT   (3U)
 
#define ENET_RCR_PROM(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RCR_PROM_SHIFT)) & ENET_RCR_PROM_MASK)
 
#define ENET_RCR_BC_REJ_MASK   (0x10U)
 
#define ENET_RCR_BC_REJ_SHIFT   (4U)
 
#define ENET_RCR_BC_REJ(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RCR_BC_REJ_SHIFT)) & ENET_RCR_BC_REJ_MASK)
 
#define ENET_RCR_FCE_MASK   (0x20U)
 
#define ENET_RCR_FCE_SHIFT   (5U)
 
#define ENET_RCR_FCE(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RCR_FCE_SHIFT)) & ENET_RCR_FCE_MASK)
 
#define ENET_RCR_RMII_MODE_MASK   (0x100U)
 
#define ENET_RCR_RMII_MODE_SHIFT   (8U)
 
#define ENET_RCR_RMII_MODE(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RCR_RMII_MODE_SHIFT)) & ENET_RCR_RMII_MODE_MASK)
 
#define ENET_RCR_RMII_10T_MASK   (0x200U)
 
#define ENET_RCR_RMII_10T_SHIFT   (9U)
 
#define ENET_RCR_RMII_10T(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RCR_RMII_10T_SHIFT)) & ENET_RCR_RMII_10T_MASK)
 
#define ENET_RCR_PADEN_MASK   (0x1000U)
 
#define ENET_RCR_PADEN_SHIFT   (12U)
 
#define ENET_RCR_PADEN(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RCR_PADEN_SHIFT)) & ENET_RCR_PADEN_MASK)
 
#define ENET_RCR_PAUFWD_MASK   (0x2000U)
 
#define ENET_RCR_PAUFWD_SHIFT   (13U)
 
#define ENET_RCR_PAUFWD(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RCR_PAUFWD_SHIFT)) & ENET_RCR_PAUFWD_MASK)
 
#define ENET_RCR_CRCFWD_MASK   (0x4000U)
 
#define ENET_RCR_CRCFWD_SHIFT   (14U)
 
#define ENET_RCR_CRCFWD(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RCR_CRCFWD_SHIFT)) & ENET_RCR_CRCFWD_MASK)
 
#define ENET_RCR_CFEN_MASK   (0x8000U)
 
#define ENET_RCR_CFEN_SHIFT   (15U)
 
#define ENET_RCR_CFEN(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RCR_CFEN_SHIFT)) & ENET_RCR_CFEN_MASK)
 
#define ENET_RCR_MAX_FL_MASK   (0x3FFF0000U)
 
#define ENET_RCR_MAX_FL_SHIFT   (16U)
 
#define ENET_RCR_MAX_FL(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RCR_MAX_FL_SHIFT)) & ENET_RCR_MAX_FL_MASK)
 
#define ENET_RCR_NLC_MASK   (0x40000000U)
 
#define ENET_RCR_NLC_SHIFT   (30U)
 
#define ENET_RCR_NLC(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RCR_NLC_SHIFT)) & ENET_RCR_NLC_MASK)
 
#define ENET_RCR_GRS_MASK   (0x80000000U)
 
#define ENET_RCR_GRS_SHIFT   (31U)
 
#define ENET_RCR_GRS(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RCR_GRS_SHIFT)) & ENET_RCR_GRS_MASK)
 
TCR - Transmit Control Register
#define ENET_TCR_GTS_MASK   (0x1U)
 
#define ENET_TCR_GTS_SHIFT   (0U)
 
#define ENET_TCR_GTS(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TCR_GTS_SHIFT)) & ENET_TCR_GTS_MASK)
 
#define ENET_TCR_FDEN_MASK   (0x4U)
 
#define ENET_TCR_FDEN_SHIFT   (2U)
 
#define ENET_TCR_FDEN(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TCR_FDEN_SHIFT)) & ENET_TCR_FDEN_MASK)
 
#define ENET_TCR_TFC_PAUSE_MASK   (0x8U)
 
#define ENET_TCR_TFC_PAUSE_SHIFT   (3U)
 
#define ENET_TCR_TFC_PAUSE(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TCR_TFC_PAUSE_SHIFT)) & ENET_TCR_TFC_PAUSE_MASK)
 
#define ENET_TCR_RFC_PAUSE_MASK   (0x10U)
 
#define ENET_TCR_RFC_PAUSE_SHIFT   (4U)
 
#define ENET_TCR_RFC_PAUSE(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TCR_RFC_PAUSE_SHIFT)) & ENET_TCR_RFC_PAUSE_MASK)
 
#define ENET_TCR_ADDSEL_MASK   (0xE0U)
 
#define ENET_TCR_ADDSEL_SHIFT   (5U)
 
#define ENET_TCR_ADDSEL(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TCR_ADDSEL_SHIFT)) & ENET_TCR_ADDSEL_MASK)
 
#define ENET_TCR_ADDINS_MASK   (0x100U)
 
#define ENET_TCR_ADDINS_SHIFT   (8U)
 
#define ENET_TCR_ADDINS(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TCR_ADDINS_SHIFT)) & ENET_TCR_ADDINS_MASK)
 
#define ENET_TCR_CRCFWD_MASK   (0x200U)
 
#define ENET_TCR_CRCFWD_SHIFT   (9U)
 
#define ENET_TCR_CRCFWD(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TCR_CRCFWD_SHIFT)) & ENET_TCR_CRCFWD_MASK)
 
PALR - Physical Address Lower Register
#define ENET_PALR_PADDR1_MASK   (0xFFFFFFFFU)
 
#define ENET_PALR_PADDR1_SHIFT   (0U)
 
#define ENET_PALR_PADDR1(x)   (((uint32_t)(((uint32_t)(x)) << ENET_PALR_PADDR1_SHIFT)) & ENET_PALR_PADDR1_MASK)
 
PAUR - Physical Address Upper Register
#define ENET_PAUR_TYPE_MASK   (0xFFFFU)
 
#define ENET_PAUR_TYPE_SHIFT   (0U)
 
#define ENET_PAUR_TYPE(x)   (((uint32_t)(((uint32_t)(x)) << ENET_PAUR_TYPE_SHIFT)) & ENET_PAUR_TYPE_MASK)
 
#define ENET_PAUR_PADDR2_MASK   (0xFFFF0000U)
 
#define ENET_PAUR_PADDR2_SHIFT   (16U)
 
#define ENET_PAUR_PADDR2(x)   (((uint32_t)(((uint32_t)(x)) << ENET_PAUR_PADDR2_SHIFT)) & ENET_PAUR_PADDR2_MASK)
 
OPD - Opcode/Pause Duration Register
#define ENET_OPD_PAUSE_DUR_MASK   (0xFFFFU)
 
#define ENET_OPD_PAUSE_DUR_SHIFT   (0U)
 
#define ENET_OPD_PAUSE_DUR(x)   (((uint32_t)(((uint32_t)(x)) << ENET_OPD_PAUSE_DUR_SHIFT)) & ENET_OPD_PAUSE_DUR_MASK)
 
#define ENET_OPD_OPCODE_MASK   (0xFFFF0000U)
 
#define ENET_OPD_OPCODE_SHIFT   (16U)
 
#define ENET_OPD_OPCODE(x)   (((uint32_t)(((uint32_t)(x)) << ENET_OPD_OPCODE_SHIFT)) & ENET_OPD_OPCODE_MASK)
 
IAUR - Descriptor Individual Upper Address Register
#define ENET_IAUR_IADDR1_MASK   (0xFFFFFFFFU)
 
#define ENET_IAUR_IADDR1_SHIFT   (0U)
 
#define ENET_IAUR_IADDR1(x)   (((uint32_t)(((uint32_t)(x)) << ENET_IAUR_IADDR1_SHIFT)) & ENET_IAUR_IADDR1_MASK)
 
IALR - Descriptor Individual Lower Address Register
#define ENET_IALR_IADDR2_MASK   (0xFFFFFFFFU)
 
#define ENET_IALR_IADDR2_SHIFT   (0U)
 
#define ENET_IALR_IADDR2(x)   (((uint32_t)(((uint32_t)(x)) << ENET_IALR_IADDR2_SHIFT)) & ENET_IALR_IADDR2_MASK)
 
GAUR - Descriptor Group Upper Address Register
#define ENET_GAUR_GADDR1_MASK   (0xFFFFFFFFU)
 
#define ENET_GAUR_GADDR1_SHIFT   (0U)
 
#define ENET_GAUR_GADDR1(x)   (((uint32_t)(((uint32_t)(x)) << ENET_GAUR_GADDR1_SHIFT)) & ENET_GAUR_GADDR1_MASK)
 
GALR - Descriptor Group Lower Address Register
#define ENET_GALR_GADDR2_MASK   (0xFFFFFFFFU)
 
#define ENET_GALR_GADDR2_SHIFT   (0U)
 
#define ENET_GALR_GADDR2(x)   (((uint32_t)(((uint32_t)(x)) << ENET_GALR_GADDR2_SHIFT)) & ENET_GALR_GADDR2_MASK)
 
TFWR - Transmit FIFO Watermark Register
#define ENET_TFWR_TFWR_MASK   (0x3FU)
 
#define ENET_TFWR_TFWR_SHIFT   (0U)
 
#define ENET_TFWR_TFWR(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TFWR_TFWR_SHIFT)) & ENET_TFWR_TFWR_MASK)
 
#define ENET_TFWR_STRFWD_MASK   (0x100U)
 
#define ENET_TFWR_STRFWD_SHIFT   (8U)
 
#define ENET_TFWR_STRFWD(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TFWR_STRFWD_SHIFT)) & ENET_TFWR_STRFWD_MASK)
 
RDSR - Receive Descriptor Ring Start Register
#define ENET_RDSR_R_DES_START_MASK   (0xFFFFFFF8U)
 
#define ENET_RDSR_R_DES_START_SHIFT   (3U)
 
#define ENET_RDSR_R_DES_START(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RDSR_R_DES_START_SHIFT)) & ENET_RDSR_R_DES_START_MASK)
 
TDSR - Transmit Buffer Descriptor Ring Start Register
#define ENET_TDSR_X_DES_START_MASK   (0xFFFFFFF8U)
 
#define ENET_TDSR_X_DES_START_SHIFT   (3U)
 
#define ENET_TDSR_X_DES_START(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TDSR_X_DES_START_SHIFT)) & ENET_TDSR_X_DES_START_MASK)
 
MRBR - Maximum Receive Buffer Size Register
#define ENET_MRBR_R_BUF_SIZE_MASK   (0x3FF0U)
 
#define ENET_MRBR_R_BUF_SIZE_SHIFT   (4U)
 
#define ENET_MRBR_R_BUF_SIZE(x)   (((uint32_t)(((uint32_t)(x)) << ENET_MRBR_R_BUF_SIZE_SHIFT)) & ENET_MRBR_R_BUF_SIZE_MASK)
 
RSFL - Receive FIFO Section Full Threshold
#define ENET_RSFL_RX_SECTION_FULL_MASK   (0xFFU)
 
#define ENET_RSFL_RX_SECTION_FULL_SHIFT   (0U)
 
#define ENET_RSFL_RX_SECTION_FULL(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RSFL_RX_SECTION_FULL_SHIFT)) & ENET_RSFL_RX_SECTION_FULL_MASK)
 
RSEM - Receive FIFO Section Empty Threshold
#define ENET_RSEM_RX_SECTION_EMPTY_MASK   (0xFFU)
 
#define ENET_RSEM_RX_SECTION_EMPTY_SHIFT   (0U)
 
#define ENET_RSEM_RX_SECTION_EMPTY(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RSEM_RX_SECTION_EMPTY_SHIFT)) & ENET_RSEM_RX_SECTION_EMPTY_MASK)
 
#define ENET_RSEM_STAT_SECTION_EMPTY_MASK   (0x1F0000U)
 
#define ENET_RSEM_STAT_SECTION_EMPTY_SHIFT   (16U)
 
#define ENET_RSEM_STAT_SECTION_EMPTY(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RSEM_STAT_SECTION_EMPTY_SHIFT)) & ENET_RSEM_STAT_SECTION_EMPTY_MASK)
 
RAEM - Receive FIFO Almost Empty Threshold
#define ENET_RAEM_RX_ALMOST_EMPTY_MASK   (0xFFU)
 
#define ENET_RAEM_RX_ALMOST_EMPTY_SHIFT   (0U)
 
#define ENET_RAEM_RX_ALMOST_EMPTY(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RAEM_RX_ALMOST_EMPTY_SHIFT)) & ENET_RAEM_RX_ALMOST_EMPTY_MASK)
 
RAFL - Receive FIFO Almost Full Threshold
#define ENET_RAFL_RX_ALMOST_FULL_MASK   (0xFFU)
 
#define ENET_RAFL_RX_ALMOST_FULL_SHIFT   (0U)
 
#define ENET_RAFL_RX_ALMOST_FULL(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RAFL_RX_ALMOST_FULL_SHIFT)) & ENET_RAFL_RX_ALMOST_FULL_MASK)
 
TSEM - Transmit FIFO Section Empty Threshold
#define ENET_TSEM_TX_SECTION_EMPTY_MASK   (0xFFU)
 
#define ENET_TSEM_TX_SECTION_EMPTY_SHIFT   (0U)
 
#define ENET_TSEM_TX_SECTION_EMPTY(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TSEM_TX_SECTION_EMPTY_SHIFT)) & ENET_TSEM_TX_SECTION_EMPTY_MASK)
 
TAEM - Transmit FIFO Almost Empty Threshold
#define ENET_TAEM_TX_ALMOST_EMPTY_MASK   (0xFFU)
 
#define ENET_TAEM_TX_ALMOST_EMPTY_SHIFT   (0U)
 
#define ENET_TAEM_TX_ALMOST_EMPTY(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TAEM_TX_ALMOST_EMPTY_SHIFT)) & ENET_TAEM_TX_ALMOST_EMPTY_MASK)
 
TAFL - Transmit FIFO Almost Full Threshold
#define ENET_TAFL_TX_ALMOST_FULL_MASK   (0xFFU)
 
#define ENET_TAFL_TX_ALMOST_FULL_SHIFT   (0U)
 
#define ENET_TAFL_TX_ALMOST_FULL(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TAFL_TX_ALMOST_FULL_SHIFT)) & ENET_TAFL_TX_ALMOST_FULL_MASK)
 
TIPG - Transmit Inter-Packet Gap
#define ENET_TIPG_IPG_MASK   (0x1FU)
 
#define ENET_TIPG_IPG_SHIFT   (0U)
 
#define ENET_TIPG_IPG(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TIPG_IPG_SHIFT)) & ENET_TIPG_IPG_MASK)
 
FTRL - Frame Truncation Length
#define ENET_FTRL_TRUNC_FL_MASK   (0x3FFFU)
 
#define ENET_FTRL_TRUNC_FL_SHIFT   (0U)
 
#define ENET_FTRL_TRUNC_FL(x)   (((uint32_t)(((uint32_t)(x)) << ENET_FTRL_TRUNC_FL_SHIFT)) & ENET_FTRL_TRUNC_FL_MASK)
 
TACC - Transmit Accelerator Function Configuration
#define ENET_TACC_SHIFT16_MASK   (0x1U)
 
#define ENET_TACC_SHIFT16_SHIFT   (0U)
 
#define ENET_TACC_SHIFT16(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TACC_SHIFT16_SHIFT)) & ENET_TACC_SHIFT16_MASK)
 
#define ENET_TACC_IPCHK_MASK   (0x8U)
 
#define ENET_TACC_IPCHK_SHIFT   (3U)
 
#define ENET_TACC_IPCHK(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TACC_IPCHK_SHIFT)) & ENET_TACC_IPCHK_MASK)
 
#define ENET_TACC_PROCHK_MASK   (0x10U)
 
#define ENET_TACC_PROCHK_SHIFT   (4U)
 
#define ENET_TACC_PROCHK(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TACC_PROCHK_SHIFT)) & ENET_TACC_PROCHK_MASK)
 
RACC - Receive Accelerator Function Configuration
#define ENET_RACC_PADREM_MASK   (0x1U)
 
#define ENET_RACC_PADREM_SHIFT   (0U)
 
#define ENET_RACC_PADREM(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RACC_PADREM_SHIFT)) & ENET_RACC_PADREM_MASK)
 
#define ENET_RACC_IPDIS_MASK   (0x2U)
 
#define ENET_RACC_IPDIS_SHIFT   (1U)
 
#define ENET_RACC_IPDIS(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RACC_IPDIS_SHIFT)) & ENET_RACC_IPDIS_MASK)
 
#define ENET_RACC_PRODIS_MASK   (0x4U)
 
#define ENET_RACC_PRODIS_SHIFT   (2U)
 
#define ENET_RACC_PRODIS(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RACC_PRODIS_SHIFT)) & ENET_RACC_PRODIS_MASK)
 
#define ENET_RACC_LINEDIS_MASK   (0x40U)
 
#define ENET_RACC_LINEDIS_SHIFT   (6U)
 
#define ENET_RACC_LINEDIS(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RACC_LINEDIS_SHIFT)) & ENET_RACC_LINEDIS_MASK)
 
#define ENET_RACC_SHIFT16_MASK   (0x80U)
 
#define ENET_RACC_SHIFT16_SHIFT   (7U)
 
#define ENET_RACC_SHIFT16(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RACC_SHIFT16_SHIFT)) & ENET_RACC_SHIFT16_MASK)
 
RMON_T_PACKETS - Tx Packet Count Statistic Register
#define ENET_RMON_T_PACKETS_TXPKTS_MASK   (0xFFFFU)
 
#define ENET_RMON_T_PACKETS_TXPKTS_SHIFT   (0U)
 
#define ENET_RMON_T_PACKETS_TXPKTS(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_T_PACKETS_TXPKTS_SHIFT)) & ENET_RMON_T_PACKETS_TXPKTS_MASK)
 
RMON_T_BC_PKT - Tx Broadcast Packets Statistic Register
#define ENET_RMON_T_BC_PKT_TXPKTS_MASK   (0xFFFFU)
 
#define ENET_RMON_T_BC_PKT_TXPKTS_SHIFT   (0U)
 
#define ENET_RMON_T_BC_PKT_TXPKTS(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_T_BC_PKT_TXPKTS_SHIFT)) & ENET_RMON_T_BC_PKT_TXPKTS_MASK)
 
RMON_T_MC_PKT - Tx Multicast Packets Statistic Register
#define ENET_RMON_T_MC_PKT_TXPKTS_MASK   (0xFFFFU)
 
#define ENET_RMON_T_MC_PKT_TXPKTS_SHIFT   (0U)
 
#define ENET_RMON_T_MC_PKT_TXPKTS(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_T_MC_PKT_TXPKTS_SHIFT)) & ENET_RMON_T_MC_PKT_TXPKTS_MASK)
 
RMON_T_CRC_ALIGN - Tx Packets with CRC/Align Error Statistic Register
#define ENET_RMON_T_CRC_ALIGN_TXPKTS_MASK   (0xFFFFU)
 
#define ENET_RMON_T_CRC_ALIGN_TXPKTS_SHIFT   (0U)
 
#define ENET_RMON_T_CRC_ALIGN_TXPKTS(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_T_CRC_ALIGN_TXPKTS_SHIFT)) & ENET_RMON_T_CRC_ALIGN_TXPKTS_MASK)
 
RMON_T_UNDERSIZE - Tx Packets Less Than Bytes and Good CRC Statistic Register
#define ENET_RMON_T_UNDERSIZE_TXPKTS_MASK   (0xFFFFU)
 
#define ENET_RMON_T_UNDERSIZE_TXPKTS_SHIFT   (0U)
 
#define ENET_RMON_T_UNDERSIZE_TXPKTS(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_T_UNDERSIZE_TXPKTS_SHIFT)) & ENET_RMON_T_UNDERSIZE_TXPKTS_MASK)
 
RMON_T_OVERSIZE - Tx Packets GT MAX_FL bytes and Good CRC Statistic Register
#define ENET_RMON_T_OVERSIZE_TXPKTS_MASK   (0xFFFFU)
 
#define ENET_RMON_T_OVERSIZE_TXPKTS_SHIFT   (0U)
 
#define ENET_RMON_T_OVERSIZE_TXPKTS(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_T_OVERSIZE_TXPKTS_SHIFT)) & ENET_RMON_T_OVERSIZE_TXPKTS_MASK)
 
RMON_T_FRAG - Tx Packets Less Than 64 Bytes and Bad CRC Statistic Register
#define ENET_RMON_T_FRAG_TXPKTS_MASK   (0xFFFFU)
 
#define ENET_RMON_T_FRAG_TXPKTS_SHIFT   (0U)
 
#define ENET_RMON_T_FRAG_TXPKTS(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_T_FRAG_TXPKTS_SHIFT)) & ENET_RMON_T_FRAG_TXPKTS_MASK)
 
RMON_T_JAB - Tx Packets Greater Than MAX_FL bytes and Bad CRC Statistic Register
#define ENET_RMON_T_JAB_TXPKTS_MASK   (0xFFFFU)
 
#define ENET_RMON_T_JAB_TXPKTS_SHIFT   (0U)
 
#define ENET_RMON_T_JAB_TXPKTS(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_T_JAB_TXPKTS_SHIFT)) & ENET_RMON_T_JAB_TXPKTS_MASK)
 
RMON_T_COL - Tx Collision Count Statistic Register
#define ENET_RMON_T_COL_TXPKTS_MASK   (0xFFFFU)
 
#define ENET_RMON_T_COL_TXPKTS_SHIFT   (0U)
 
#define ENET_RMON_T_COL_TXPKTS(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_T_COL_TXPKTS_SHIFT)) & ENET_RMON_T_COL_TXPKTS_MASK)
 
RMON_T_P64 - Tx 64-Byte Packets Statistic Register
#define ENET_RMON_T_P64_TXPKTS_MASK   (0xFFFFU)
 
#define ENET_RMON_T_P64_TXPKTS_SHIFT   (0U)
 
#define ENET_RMON_T_P64_TXPKTS(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_T_P64_TXPKTS_SHIFT)) & ENET_RMON_T_P64_TXPKTS_MASK)
 
RMON_T_P65TO127 - Tx 65- to 127-byte Packets Statistic Register
#define ENET_RMON_T_P65TO127_TXPKTS_MASK   (0xFFFFU)
 
#define ENET_RMON_T_P65TO127_TXPKTS_SHIFT   (0U)
 
#define ENET_RMON_T_P65TO127_TXPKTS(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_T_P65TO127_TXPKTS_SHIFT)) & ENET_RMON_T_P65TO127_TXPKTS_MASK)
 
RMON_T_P128TO255 - Tx 128- to 255-byte Packets Statistic Register
#define ENET_RMON_T_P128TO255_TXPKTS_MASK   (0xFFFFU)
 
#define ENET_RMON_T_P128TO255_TXPKTS_SHIFT   (0U)
 
#define ENET_RMON_T_P128TO255_TXPKTS(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_T_P128TO255_TXPKTS_SHIFT)) & ENET_RMON_T_P128TO255_TXPKTS_MASK)
 
RMON_T_P256TO511 - Tx 256- to 511-byte Packets Statistic Register
#define ENET_RMON_T_P256TO511_TXPKTS_MASK   (0xFFFFU)
 
#define ENET_RMON_T_P256TO511_TXPKTS_SHIFT   (0U)
 
#define ENET_RMON_T_P256TO511_TXPKTS(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_T_P256TO511_TXPKTS_SHIFT)) & ENET_RMON_T_P256TO511_TXPKTS_MASK)
 
RMON_T_P512TO1023 - Tx 512- to 1023-byte Packets Statistic Register
#define ENET_RMON_T_P512TO1023_TXPKTS_MASK   (0xFFFFU)
 
#define ENET_RMON_T_P512TO1023_TXPKTS_SHIFT   (0U)
 
#define ENET_RMON_T_P512TO1023_TXPKTS(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_T_P512TO1023_TXPKTS_SHIFT)) & ENET_RMON_T_P512TO1023_TXPKTS_MASK)
 
RMON_T_P1024TO2047 - Tx 1024- to 2047-byte Packets Statistic Register
#define ENET_RMON_T_P1024TO2047_TXPKTS_MASK   (0xFFFFU)
 
#define ENET_RMON_T_P1024TO2047_TXPKTS_SHIFT   (0U)
 
#define ENET_RMON_T_P1024TO2047_TXPKTS(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_T_P1024TO2047_TXPKTS_SHIFT)) & ENET_RMON_T_P1024TO2047_TXPKTS_MASK)
 
RMON_T_P_GTE2048 - Tx Packets Greater Than 2048 Bytes Statistic Register
#define ENET_RMON_T_P_GTE2048_TXPKTS_MASK   (0xFFFFU)
 
#define ENET_RMON_T_P_GTE2048_TXPKTS_SHIFT   (0U)
 
#define ENET_RMON_T_P_GTE2048_TXPKTS(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_T_P_GTE2048_TXPKTS_SHIFT)) & ENET_RMON_T_P_GTE2048_TXPKTS_MASK)
 
RMON_T_OCTETS - Tx Octets Statistic Register
#define ENET_RMON_T_OCTETS_TXOCTS_MASK   (0xFFFFFFFFU)
 
#define ENET_RMON_T_OCTETS_TXOCTS_SHIFT   (0U)
 
#define ENET_RMON_T_OCTETS_TXOCTS(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_T_OCTETS_TXOCTS_SHIFT)) & ENET_RMON_T_OCTETS_TXOCTS_MASK)
 
IEEE_T_FRAME_OK - Frames Transmitted OK Statistic Register
#define ENET_IEEE_T_FRAME_OK_COUNT_MASK   (0xFFFFU)
 
#define ENET_IEEE_T_FRAME_OK_COUNT_SHIFT   (0U)
 
#define ENET_IEEE_T_FRAME_OK_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_IEEE_T_FRAME_OK_COUNT_SHIFT)) & ENET_IEEE_T_FRAME_OK_COUNT_MASK)
 
IEEE_T_1COL - Frames Transmitted with Single Collision Statistic Register
#define ENET_IEEE_T_1COL_COUNT_MASK   (0xFFFFU)
 
#define ENET_IEEE_T_1COL_COUNT_SHIFT   (0U)
 
#define ENET_IEEE_T_1COL_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_IEEE_T_1COL_COUNT_SHIFT)) & ENET_IEEE_T_1COL_COUNT_MASK)
 
IEEE_T_MCOL - Frames Transmitted with Multiple Collisions Statistic Register
#define ENET_IEEE_T_MCOL_COUNT_MASK   (0xFFFFU)
 
#define ENET_IEEE_T_MCOL_COUNT_SHIFT   (0U)
 
#define ENET_IEEE_T_MCOL_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_IEEE_T_MCOL_COUNT_SHIFT)) & ENET_IEEE_T_MCOL_COUNT_MASK)
 
IEEE_T_DEF - Frames Transmitted after Deferral Delay Statistic Register
#define ENET_IEEE_T_DEF_COUNT_MASK   (0xFFFFU)
 
#define ENET_IEEE_T_DEF_COUNT_SHIFT   (0U)
 
#define ENET_IEEE_T_DEF_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_IEEE_T_DEF_COUNT_SHIFT)) & ENET_IEEE_T_DEF_COUNT_MASK)
 
IEEE_T_LCOL - Frames Transmitted with Late Collision Statistic Register
#define ENET_IEEE_T_LCOL_COUNT_MASK   (0xFFFFU)
 
#define ENET_IEEE_T_LCOL_COUNT_SHIFT   (0U)
 
#define ENET_IEEE_T_LCOL_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_IEEE_T_LCOL_COUNT_SHIFT)) & ENET_IEEE_T_LCOL_COUNT_MASK)
 
IEEE_T_EXCOL - Frames Transmitted with Excessive Collisions Statistic Register
#define ENET_IEEE_T_EXCOL_COUNT_MASK   (0xFFFFU)
 
#define ENET_IEEE_T_EXCOL_COUNT_SHIFT   (0U)
 
#define ENET_IEEE_T_EXCOL_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_IEEE_T_EXCOL_COUNT_SHIFT)) & ENET_IEEE_T_EXCOL_COUNT_MASK)
 
IEEE_T_MACERR - Frames Transmitted with Tx FIFO Underrun Statistic Register
#define ENET_IEEE_T_MACERR_COUNT_MASK   (0xFFFFU)
 
#define ENET_IEEE_T_MACERR_COUNT_SHIFT   (0U)
 
#define ENET_IEEE_T_MACERR_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_IEEE_T_MACERR_COUNT_SHIFT)) & ENET_IEEE_T_MACERR_COUNT_MASK)
 
IEEE_T_CSERR - Frames Transmitted with Carrier Sense Error Statistic Register
#define ENET_IEEE_T_CSERR_COUNT_MASK   (0xFFFFU)
 
#define ENET_IEEE_T_CSERR_COUNT_SHIFT   (0U)
 
#define ENET_IEEE_T_CSERR_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_IEEE_T_CSERR_COUNT_SHIFT)) & ENET_IEEE_T_CSERR_COUNT_MASK)
 
IEEE_T_FDXFC - Flow Control Pause Frames Transmitted Statistic Register
#define ENET_IEEE_T_FDXFC_COUNT_MASK   (0xFFFFU)
 
#define ENET_IEEE_T_FDXFC_COUNT_SHIFT   (0U)
 
#define ENET_IEEE_T_FDXFC_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_IEEE_T_FDXFC_COUNT_SHIFT)) & ENET_IEEE_T_FDXFC_COUNT_MASK)
 
IEEE_T_OCTETS_OK - Octet Count for Frames Transmitted w/o Error Statistic Register
#define ENET_IEEE_T_OCTETS_OK_COUNT_MASK   (0xFFFFFFFFU)
 
#define ENET_IEEE_T_OCTETS_OK_COUNT_SHIFT   (0U)
 
#define ENET_IEEE_T_OCTETS_OK_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_IEEE_T_OCTETS_OK_COUNT_SHIFT)) & ENET_IEEE_T_OCTETS_OK_COUNT_MASK)
 
RMON_R_PACKETS - Rx Packet Count Statistic Register
#define ENET_RMON_R_PACKETS_COUNT_MASK   (0xFFFFU)
 
#define ENET_RMON_R_PACKETS_COUNT_SHIFT   (0U)
 
#define ENET_RMON_R_PACKETS_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_R_PACKETS_COUNT_SHIFT)) & ENET_RMON_R_PACKETS_COUNT_MASK)
 
RMON_R_BC_PKT - Rx Broadcast Packets Statistic Register
#define ENET_RMON_R_BC_PKT_COUNT_MASK   (0xFFFFU)
 
#define ENET_RMON_R_BC_PKT_COUNT_SHIFT   (0U)
 
#define ENET_RMON_R_BC_PKT_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_R_BC_PKT_COUNT_SHIFT)) & ENET_RMON_R_BC_PKT_COUNT_MASK)
 
RMON_R_MC_PKT - Rx Multicast Packets Statistic Register
#define ENET_RMON_R_MC_PKT_COUNT_MASK   (0xFFFFU)
 
#define ENET_RMON_R_MC_PKT_COUNT_SHIFT   (0U)
 
#define ENET_RMON_R_MC_PKT_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_R_MC_PKT_COUNT_SHIFT)) & ENET_RMON_R_MC_PKT_COUNT_MASK)
 
RMON_R_CRC_ALIGN - Rx Packets with CRC/Align Error Statistic Register
#define ENET_RMON_R_CRC_ALIGN_COUNT_MASK   (0xFFFFU)
 
#define ENET_RMON_R_CRC_ALIGN_COUNT_SHIFT   (0U)
 
#define ENET_RMON_R_CRC_ALIGN_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_R_CRC_ALIGN_COUNT_SHIFT)) & ENET_RMON_R_CRC_ALIGN_COUNT_MASK)
 
RMON_R_UNDERSIZE - Rx Packets with Less Than 64 Bytes and Good CRC Statistic Register
#define ENET_RMON_R_UNDERSIZE_COUNT_MASK   (0xFFFFU)
 
#define ENET_RMON_R_UNDERSIZE_COUNT_SHIFT   (0U)
 
#define ENET_RMON_R_UNDERSIZE_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_R_UNDERSIZE_COUNT_SHIFT)) & ENET_RMON_R_UNDERSIZE_COUNT_MASK)
 
RMON_R_OVERSIZE - Rx Packets Greater Than MAX_FL and Good CRC Statistic Register
#define ENET_RMON_R_OVERSIZE_COUNT_MASK   (0xFFFFU)
 
#define ENET_RMON_R_OVERSIZE_COUNT_SHIFT   (0U)
 
#define ENET_RMON_R_OVERSIZE_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_R_OVERSIZE_COUNT_SHIFT)) & ENET_RMON_R_OVERSIZE_COUNT_MASK)
 
RMON_R_FRAG - Rx Packets Less Than 64 Bytes and Bad CRC Statistic Register
#define ENET_RMON_R_FRAG_COUNT_MASK   (0xFFFFU)
 
#define ENET_RMON_R_FRAG_COUNT_SHIFT   (0U)
 
#define ENET_RMON_R_FRAG_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_R_FRAG_COUNT_SHIFT)) & ENET_RMON_R_FRAG_COUNT_MASK)
 
RMON_R_JAB - Rx Packets Greater Than MAX_FL Bytes and Bad CRC Statistic Register
#define ENET_RMON_R_JAB_COUNT_MASK   (0xFFFFU)
 
#define ENET_RMON_R_JAB_COUNT_SHIFT   (0U)
 
#define ENET_RMON_R_JAB_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_R_JAB_COUNT_SHIFT)) & ENET_RMON_R_JAB_COUNT_MASK)
 
RMON_R_P64 - Rx 64-Byte Packets Statistic Register
#define ENET_RMON_R_P64_COUNT_MASK   (0xFFFFU)
 
#define ENET_RMON_R_P64_COUNT_SHIFT   (0U)
 
#define ENET_RMON_R_P64_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_R_P64_COUNT_SHIFT)) & ENET_RMON_R_P64_COUNT_MASK)
 
RMON_R_P65TO127 - Rx 65- to 127-Byte Packets Statistic Register
#define ENET_RMON_R_P65TO127_COUNT_MASK   (0xFFFFU)
 
#define ENET_RMON_R_P65TO127_COUNT_SHIFT   (0U)
 
#define ENET_RMON_R_P65TO127_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_R_P65TO127_COUNT_SHIFT)) & ENET_RMON_R_P65TO127_COUNT_MASK)
 
RMON_R_P128TO255 - Rx 128- to 255-Byte Packets Statistic Register
#define ENET_RMON_R_P128TO255_COUNT_MASK   (0xFFFFU)
 
#define ENET_RMON_R_P128TO255_COUNT_SHIFT   (0U)
 
#define ENET_RMON_R_P128TO255_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_R_P128TO255_COUNT_SHIFT)) & ENET_RMON_R_P128TO255_COUNT_MASK)
 
RMON_R_P256TO511 - Rx 256- to 511-Byte Packets Statistic Register
#define ENET_RMON_R_P256TO511_COUNT_MASK   (0xFFFFU)
 
#define ENET_RMON_R_P256TO511_COUNT_SHIFT   (0U)
 
#define ENET_RMON_R_P256TO511_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_R_P256TO511_COUNT_SHIFT)) & ENET_RMON_R_P256TO511_COUNT_MASK)
 
RMON_R_P512TO1023 - Rx 512- to 1023-Byte Packets Statistic Register
#define ENET_RMON_R_P512TO1023_COUNT_MASK   (0xFFFFU)
 
#define ENET_RMON_R_P512TO1023_COUNT_SHIFT   (0U)
 
#define ENET_RMON_R_P512TO1023_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_R_P512TO1023_COUNT_SHIFT)) & ENET_RMON_R_P512TO1023_COUNT_MASK)
 
RMON_R_P1024TO2047 - Rx 1024- to 2047-Byte Packets Statistic Register
#define ENET_RMON_R_P1024TO2047_COUNT_MASK   (0xFFFFU)
 
#define ENET_RMON_R_P1024TO2047_COUNT_SHIFT   (0U)
 
#define ENET_RMON_R_P1024TO2047_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_R_P1024TO2047_COUNT_SHIFT)) & ENET_RMON_R_P1024TO2047_COUNT_MASK)
 
RMON_R_P_GTE2048 - Rx Packets Greater than 2048 Bytes Statistic Register
#define ENET_RMON_R_P_GTE2048_COUNT_MASK   (0xFFFFU)
 
#define ENET_RMON_R_P_GTE2048_COUNT_SHIFT   (0U)
 
#define ENET_RMON_R_P_GTE2048_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_R_P_GTE2048_COUNT_SHIFT)) & ENET_RMON_R_P_GTE2048_COUNT_MASK)
 
RMON_R_OCTETS - Rx Octets Statistic Register
#define ENET_RMON_R_OCTETS_COUNT_MASK   (0xFFFFFFFFU)
 
#define ENET_RMON_R_OCTETS_COUNT_SHIFT   (0U)
 
#define ENET_RMON_R_OCTETS_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_RMON_R_OCTETS_COUNT_SHIFT)) & ENET_RMON_R_OCTETS_COUNT_MASK)
 
IEEE_R_DROP - Frames not Counted Correctly Statistic Register
#define ENET_IEEE_R_DROP_COUNT_MASK   (0xFFFFU)
 
#define ENET_IEEE_R_DROP_COUNT_SHIFT   (0U)
 
#define ENET_IEEE_R_DROP_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_IEEE_R_DROP_COUNT_SHIFT)) & ENET_IEEE_R_DROP_COUNT_MASK)
 
IEEE_R_FRAME_OK - Frames Received OK Statistic Register
#define ENET_IEEE_R_FRAME_OK_COUNT_MASK   (0xFFFFU)
 
#define ENET_IEEE_R_FRAME_OK_COUNT_SHIFT   (0U)
 
#define ENET_IEEE_R_FRAME_OK_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_IEEE_R_FRAME_OK_COUNT_SHIFT)) & ENET_IEEE_R_FRAME_OK_COUNT_MASK)
 
IEEE_R_CRC - Frames Received with CRC Error Statistic Register
#define ENET_IEEE_R_CRC_COUNT_MASK   (0xFFFFU)
 
#define ENET_IEEE_R_CRC_COUNT_SHIFT   (0U)
 
#define ENET_IEEE_R_CRC_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_IEEE_R_CRC_COUNT_SHIFT)) & ENET_IEEE_R_CRC_COUNT_MASK)
 
IEEE_R_ALIGN - Frames Received with Alignment Error Statistic Register
#define ENET_IEEE_R_ALIGN_COUNT_MASK   (0xFFFFU)
 
#define ENET_IEEE_R_ALIGN_COUNT_SHIFT   (0U)
 
#define ENET_IEEE_R_ALIGN_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_IEEE_R_ALIGN_COUNT_SHIFT)) & ENET_IEEE_R_ALIGN_COUNT_MASK)
 
IEEE_R_MACERR - Receive FIFO Overflow Count Statistic Register
#define ENET_IEEE_R_MACERR_COUNT_MASK   (0xFFFFU)
 
#define ENET_IEEE_R_MACERR_COUNT_SHIFT   (0U)
 
#define ENET_IEEE_R_MACERR_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_IEEE_R_MACERR_COUNT_SHIFT)) & ENET_IEEE_R_MACERR_COUNT_MASK)
 
IEEE_R_FDXFC - Flow Control Pause Frames Received Statistic Register
#define ENET_IEEE_R_FDXFC_COUNT_MASK   (0xFFFFU)
 
#define ENET_IEEE_R_FDXFC_COUNT_SHIFT   (0U)
 
#define ENET_IEEE_R_FDXFC_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_IEEE_R_FDXFC_COUNT_SHIFT)) & ENET_IEEE_R_FDXFC_COUNT_MASK)
 
IEEE_R_OCTETS_OK - Octet Count for Frames Received without Error Statistic Register
#define ENET_IEEE_R_OCTETS_OK_COUNT_MASK   (0xFFFFFFFFU)
 
#define ENET_IEEE_R_OCTETS_OK_COUNT_SHIFT   (0U)
 
#define ENET_IEEE_R_OCTETS_OK_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << ENET_IEEE_R_OCTETS_OK_COUNT_SHIFT)) & ENET_IEEE_R_OCTETS_OK_COUNT_MASK)
 
ATCR - Adjustable Timer Control Register
#define ENET_ATCR_EN_MASK   (0x1U)
 
#define ENET_ATCR_EN_SHIFT   (0U)
 
#define ENET_ATCR_EN(x)   (((uint32_t)(((uint32_t)(x)) << ENET_ATCR_EN_SHIFT)) & ENET_ATCR_EN_MASK)
 
#define ENET_ATCR_OFFEN_MASK   (0x4U)
 
#define ENET_ATCR_OFFEN_SHIFT   (2U)
 
#define ENET_ATCR_OFFEN(x)   (((uint32_t)(((uint32_t)(x)) << ENET_ATCR_OFFEN_SHIFT)) & ENET_ATCR_OFFEN_MASK)
 
#define ENET_ATCR_OFFRST_MASK   (0x8U)
 
#define ENET_ATCR_OFFRST_SHIFT   (3U)
 
#define ENET_ATCR_OFFRST(x)   (((uint32_t)(((uint32_t)(x)) << ENET_ATCR_OFFRST_SHIFT)) & ENET_ATCR_OFFRST_MASK)
 
#define ENET_ATCR_PEREN_MASK   (0x10U)
 
#define ENET_ATCR_PEREN_SHIFT   (4U)
 
#define ENET_ATCR_PEREN(x)   (((uint32_t)(((uint32_t)(x)) << ENET_ATCR_PEREN_SHIFT)) & ENET_ATCR_PEREN_MASK)
 
#define ENET_ATCR_PINPER_MASK   (0x80U)
 
#define ENET_ATCR_PINPER_SHIFT   (7U)
 
#define ENET_ATCR_PINPER(x)   (((uint32_t)(((uint32_t)(x)) << ENET_ATCR_PINPER_SHIFT)) & ENET_ATCR_PINPER_MASK)
 
#define ENET_ATCR_RESTART_MASK   (0x200U)
 
#define ENET_ATCR_RESTART_SHIFT   (9U)
 
#define ENET_ATCR_RESTART(x)   (((uint32_t)(((uint32_t)(x)) << ENET_ATCR_RESTART_SHIFT)) & ENET_ATCR_RESTART_MASK)
 
#define ENET_ATCR_CAPTURE_MASK   (0x800U)
 
#define ENET_ATCR_CAPTURE_SHIFT   (11U)
 
#define ENET_ATCR_CAPTURE(x)   (((uint32_t)(((uint32_t)(x)) << ENET_ATCR_CAPTURE_SHIFT)) & ENET_ATCR_CAPTURE_MASK)
 
#define ENET_ATCR_SLAVE_MASK   (0x2000U)
 
#define ENET_ATCR_SLAVE_SHIFT   (13U)
 
#define ENET_ATCR_SLAVE(x)   (((uint32_t)(((uint32_t)(x)) << ENET_ATCR_SLAVE_SHIFT)) & ENET_ATCR_SLAVE_MASK)
 
ATVR - Timer Value Register
#define ENET_ATVR_ATIME_MASK   (0xFFFFFFFFU)
 
#define ENET_ATVR_ATIME_SHIFT   (0U)
 
#define ENET_ATVR_ATIME(x)   (((uint32_t)(((uint32_t)(x)) << ENET_ATVR_ATIME_SHIFT)) & ENET_ATVR_ATIME_MASK)
 
ATOFF - Timer Offset Register
#define ENET_ATOFF_OFFSET_MASK   (0xFFFFFFFFU)
 
#define ENET_ATOFF_OFFSET_SHIFT   (0U)
 
#define ENET_ATOFF_OFFSET(x)   (((uint32_t)(((uint32_t)(x)) << ENET_ATOFF_OFFSET_SHIFT)) & ENET_ATOFF_OFFSET_MASK)
 
ATPER - Timer Period Register
#define ENET_ATPER_PERIOD_MASK   (0xFFFFFFFFU)
 
#define ENET_ATPER_PERIOD_SHIFT   (0U)
 
#define ENET_ATPER_PERIOD(x)   (((uint32_t)(((uint32_t)(x)) << ENET_ATPER_PERIOD_SHIFT)) & ENET_ATPER_PERIOD_MASK)
 
ATCOR - Timer Correction Register
#define ENET_ATCOR_COR_MASK   (0x7FFFFFFFU)
 
#define ENET_ATCOR_COR_SHIFT   (0U)
 
#define ENET_ATCOR_COR(x)   (((uint32_t)(((uint32_t)(x)) << ENET_ATCOR_COR_SHIFT)) & ENET_ATCOR_COR_MASK)
 
ATINC - Time-Stamping Clock Period Register
#define ENET_ATINC_INC_MASK   (0x7FU)
 
#define ENET_ATINC_INC_SHIFT   (0U)
 
#define ENET_ATINC_INC(x)   (((uint32_t)(((uint32_t)(x)) << ENET_ATINC_INC_SHIFT)) & ENET_ATINC_INC_MASK)
 
#define ENET_ATINC_INC_CORR_MASK   (0x7F00U)
 
#define ENET_ATINC_INC_CORR_SHIFT   (8U)
 
#define ENET_ATINC_INC_CORR(x)   (((uint32_t)(((uint32_t)(x)) << ENET_ATINC_INC_CORR_SHIFT)) & ENET_ATINC_INC_CORR_MASK)
 
ATSTMP - Timestamp of Last Transmitted Frame
#define ENET_ATSTMP_TIMESTAMP_MASK   (0xFFFFFFFFU)
 
#define ENET_ATSTMP_TIMESTAMP_SHIFT   (0U)
 
#define ENET_ATSTMP_TIMESTAMP(x)   (((uint32_t)(((uint32_t)(x)) << ENET_ATSTMP_TIMESTAMP_SHIFT)) & ENET_ATSTMP_TIMESTAMP_MASK)
 
TGSR - Timer Global Status Register
#define ENET_TGSR_TF0_MASK   (0x1U)
 
#define ENET_TGSR_TF0_SHIFT   (0U)
 
#define ENET_TGSR_TF0(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TGSR_TF0_SHIFT)) & ENET_TGSR_TF0_MASK)
 
#define ENET_TGSR_TF1_MASK   (0x2U)
 
#define ENET_TGSR_TF1_SHIFT   (1U)
 
#define ENET_TGSR_TF1(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TGSR_TF1_SHIFT)) & ENET_TGSR_TF1_MASK)
 
#define ENET_TGSR_TF2_MASK   (0x4U)
 
#define ENET_TGSR_TF2_SHIFT   (2U)
 
#define ENET_TGSR_TF2(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TGSR_TF2_SHIFT)) & ENET_TGSR_TF2_MASK)
 
#define ENET_TGSR_TF3_MASK   (0x8U)
 
#define ENET_TGSR_TF3_SHIFT   (3U)
 
#define ENET_TGSR_TF3(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TGSR_TF3_SHIFT)) & ENET_TGSR_TF3_MASK)
 
TCSR - Timer Control Status Register
#define ENET_TCSR_TDRE_MASK   (0x1U)
 
#define ENET_TCSR_TDRE_SHIFT   (0U)
 
#define ENET_TCSR_TDRE(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TCSR_TDRE_SHIFT)) & ENET_TCSR_TDRE_MASK)
 
#define ENET_TCSR_TMODE_MASK   (0x3CU)
 
#define ENET_TCSR_TMODE_SHIFT   (2U)
 
#define ENET_TCSR_TMODE(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TCSR_TMODE_SHIFT)) & ENET_TCSR_TMODE_MASK)
 
#define ENET_TCSR_TIE_MASK   (0x40U)
 
#define ENET_TCSR_TIE_SHIFT   (6U)
 
#define ENET_TCSR_TIE(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TCSR_TIE_SHIFT)) & ENET_TCSR_TIE_MASK)
 
#define ENET_TCSR_TF_MASK   (0x80U)
 
#define ENET_TCSR_TF_SHIFT   (7U)
 
#define ENET_TCSR_TF(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TCSR_TF_SHIFT)) & ENET_TCSR_TF_MASK)
 
#define ENET_TCSR_COUNT   (4U)
 
TCCR - Timer Compare Capture Register
#define ENET_TCCR_TCC_MASK   (0xFFFFFFFFU)
 
#define ENET_TCCR_TCC_SHIFT   (0U)
 
#define ENET_TCCR_TCC(x)   (((uint32_t)(((uint32_t)(x)) << ENET_TCCR_TCC_SHIFT)) & ENET_TCCR_TCC_MASK)
 
#define ENET_TCCR_COUNT   (4U)
 
CTRL - Control Register
#define EWM_CTRL_EWMEN_MASK   (0x1U)
 
#define EWM_CTRL_EWMEN_SHIFT   (0U)
 
#define EWM_CTRL_EWMEN(x)   (((uint8_t)(((uint8_t)(x)) << EWM_CTRL_EWMEN_SHIFT)) & EWM_CTRL_EWMEN_MASK)
 
#define EWM_CTRL_ASSIN_MASK   (0x2U)
 
#define EWM_CTRL_ASSIN_SHIFT   (1U)
 
#define EWM_CTRL_ASSIN(x)   (((uint8_t)(((uint8_t)(x)) << EWM_CTRL_ASSIN_SHIFT)) & EWM_CTRL_ASSIN_MASK)
 
#define EWM_CTRL_INEN_MASK   (0x4U)
 
#define EWM_CTRL_INEN_SHIFT   (2U)
 
#define EWM_CTRL_INEN(x)   (((uint8_t)(((uint8_t)(x)) << EWM_CTRL_INEN_SHIFT)) & EWM_CTRL_INEN_MASK)
 
#define EWM_CTRL_INTEN_MASK   (0x8U)
 
#define EWM_CTRL_INTEN_SHIFT   (3U)
 
#define EWM_CTRL_INTEN(x)   (((uint8_t)(((uint8_t)(x)) << EWM_CTRL_INTEN_SHIFT)) & EWM_CTRL_INTEN_MASK)
 
SERV - Service Register
#define EWM_SERV_SERVICE_MASK   (0xFFU)
 
#define EWM_SERV_SERVICE_SHIFT   (0U)
 
#define EWM_SERV_SERVICE(x)   (((uint8_t)(((uint8_t)(x)) << EWM_SERV_SERVICE_SHIFT)) & EWM_SERV_SERVICE_MASK)
 
CMPL - Compare Low Register
#define EWM_CMPL_COMPAREL_MASK   (0xFFU)
 
#define EWM_CMPL_COMPAREL_SHIFT   (0U)
 
#define EWM_CMPL_COMPAREL(x)   (((uint8_t)(((uint8_t)(x)) << EWM_CMPL_COMPAREL_SHIFT)) & EWM_CMPL_COMPAREL_MASK)
 
CMPH - Compare High Register
#define EWM_CMPH_COMPAREH_MASK   (0xFFU)
 
#define EWM_CMPH_COMPAREH_SHIFT   (0U)
 
#define EWM_CMPH_COMPAREH(x)   (((uint8_t)(((uint8_t)(x)) << EWM_CMPH_COMPAREH_SHIFT)) & EWM_CMPH_COMPAREH_MASK)
 
CSAR - Chip Select Address Register
#define FB_CSAR_BA_MASK   (0xFFFF0000U)
 
#define FB_CSAR_BA_SHIFT   (16U)
 
#define FB_CSAR_BA(x)   (((uint32_t)(((uint32_t)(x)) << FB_CSAR_BA_SHIFT)) & FB_CSAR_BA_MASK)
 
#define FB_CSAR_COUNT   (6U)
 
CSMR - Chip Select Mask Register
#define FB_CSMR_V_MASK   (0x1U)
 
#define FB_CSMR_V_SHIFT   (0U)
 
#define FB_CSMR_V(x)   (((uint32_t)(((uint32_t)(x)) << FB_CSMR_V_SHIFT)) & FB_CSMR_V_MASK)
 
#define FB_CSMR_WP_MASK   (0x100U)
 
#define FB_CSMR_WP_SHIFT   (8U)
 
#define FB_CSMR_WP(x)   (((uint32_t)(((uint32_t)(x)) << FB_CSMR_WP_SHIFT)) & FB_CSMR_WP_MASK)
 
#define FB_CSMR_BAM_MASK   (0xFFFF0000U)
 
#define FB_CSMR_BAM_SHIFT   (16U)
 
#define FB_CSMR_BAM(x)   (((uint32_t)(((uint32_t)(x)) << FB_CSMR_BAM_SHIFT)) & FB_CSMR_BAM_MASK)
 
#define FB_CSMR_COUNT   (6U)
 
CSCR - Chip Select Control Register
#define FB_CSCR_BSTW_MASK   (0x8U)
 
#define FB_CSCR_BSTW_SHIFT   (3U)
 
#define FB_CSCR_BSTW(x)   (((uint32_t)(((uint32_t)(x)) << FB_CSCR_BSTW_SHIFT)) & FB_CSCR_BSTW_MASK)
 
#define FB_CSCR_BSTR_MASK   (0x10U)
 
#define FB_CSCR_BSTR_SHIFT   (4U)
 
#define FB_CSCR_BSTR(x)   (((uint32_t)(((uint32_t)(x)) << FB_CSCR_BSTR_SHIFT)) & FB_CSCR_BSTR_MASK)
 
#define FB_CSCR_BEM_MASK   (0x20U)
 
#define FB_CSCR_BEM_SHIFT   (5U)
 
#define FB_CSCR_BEM(x)   (((uint32_t)(((uint32_t)(x)) << FB_CSCR_BEM_SHIFT)) & FB_CSCR_BEM_MASK)
 
#define FB_CSCR_PS_MASK   (0xC0U)
 
#define FB_CSCR_PS_SHIFT   (6U)
 
#define FB_CSCR_PS(x)   (((uint32_t)(((uint32_t)(x)) << FB_CSCR_PS_SHIFT)) & FB_CSCR_PS_MASK)
 
#define FB_CSCR_AA_MASK   (0x100U)
 
#define FB_CSCR_AA_SHIFT   (8U)
 
#define FB_CSCR_AA(x)   (((uint32_t)(((uint32_t)(x)) << FB_CSCR_AA_SHIFT)) & FB_CSCR_AA_MASK)
 
#define FB_CSCR_BLS_MASK   (0x200U)
 
#define FB_CSCR_BLS_SHIFT   (9U)
 
#define FB_CSCR_BLS(x)   (((uint32_t)(((uint32_t)(x)) << FB_CSCR_BLS_SHIFT)) & FB_CSCR_BLS_MASK)
 
#define FB_CSCR_WS_MASK   (0xFC00U)
 
#define FB_CSCR_WS_SHIFT   (10U)
 
#define FB_CSCR_WS(x)   (((uint32_t)(((uint32_t)(x)) << FB_CSCR_WS_SHIFT)) & FB_CSCR_WS_MASK)
 
#define FB_CSCR_WRAH_MASK   (0x30000U)
 
#define FB_CSCR_WRAH_SHIFT   (16U)
 
#define FB_CSCR_WRAH(x)   (((uint32_t)(((uint32_t)(x)) << FB_CSCR_WRAH_SHIFT)) & FB_CSCR_WRAH_MASK)
 
#define FB_CSCR_RDAH_MASK   (0xC0000U)
 
#define FB_CSCR_RDAH_SHIFT   (18U)
 
#define FB_CSCR_RDAH(x)   (((uint32_t)(((uint32_t)(x)) << FB_CSCR_RDAH_SHIFT)) & FB_CSCR_RDAH_MASK)
 
#define FB_CSCR_ASET_MASK   (0x300000U)
 
#define FB_CSCR_ASET_SHIFT   (20U)
 
#define FB_CSCR_ASET(x)   (((uint32_t)(((uint32_t)(x)) << FB_CSCR_ASET_SHIFT)) & FB_CSCR_ASET_MASK)
 
#define FB_CSCR_EXTS_MASK   (0x400000U)
 
#define FB_CSCR_EXTS_SHIFT   (22U)
 
#define FB_CSCR_EXTS(x)   (((uint32_t)(((uint32_t)(x)) << FB_CSCR_EXTS_SHIFT)) & FB_CSCR_EXTS_MASK)
 
#define FB_CSCR_SWSEN_MASK   (0x800000U)
 
#define FB_CSCR_SWSEN_SHIFT   (23U)
 
#define FB_CSCR_SWSEN(x)   (((uint32_t)(((uint32_t)(x)) << FB_CSCR_SWSEN_SHIFT)) & FB_CSCR_SWSEN_MASK)
 
#define FB_CSCR_SWS_MASK   (0xFC000000U)
 
#define FB_CSCR_SWS_SHIFT   (26U)
 
#define FB_CSCR_SWS(x)   (((uint32_t)(((uint32_t)(x)) << FB_CSCR_SWS_SHIFT)) & FB_CSCR_SWS_MASK)
 
#define FB_CSCR_COUNT   (6U)
 
CSPMCR - Chip Select port Multiplexing Control Register
#define FB_CSPMCR_GROUP5_MASK   (0xF000U)
 
#define FB_CSPMCR_GROUP5_SHIFT   (12U)
 
#define FB_CSPMCR_GROUP5(x)   (((uint32_t)(((uint32_t)(x)) << FB_CSPMCR_GROUP5_SHIFT)) & FB_CSPMCR_GROUP5_MASK)
 
#define FB_CSPMCR_GROUP4_MASK   (0xF0000U)
 
#define FB_CSPMCR_GROUP4_SHIFT   (16U)
 
#define FB_CSPMCR_GROUP4(x)   (((uint32_t)(((uint32_t)(x)) << FB_CSPMCR_GROUP4_SHIFT)) & FB_CSPMCR_GROUP4_MASK)
 
#define FB_CSPMCR_GROUP3_MASK   (0xF00000U)
 
#define FB_CSPMCR_GROUP3_SHIFT   (20U)
 
#define FB_CSPMCR_GROUP3(x)   (((uint32_t)(((uint32_t)(x)) << FB_CSPMCR_GROUP3_SHIFT)) & FB_CSPMCR_GROUP3_MASK)
 
#define FB_CSPMCR_GROUP2_MASK   (0xF000000U)
 
#define FB_CSPMCR_GROUP2_SHIFT   (24U)
 
#define FB_CSPMCR_GROUP2(x)   (((uint32_t)(((uint32_t)(x)) << FB_CSPMCR_GROUP2_SHIFT)) & FB_CSPMCR_GROUP2_MASK)
 
#define FB_CSPMCR_GROUP1_MASK   (0xF0000000U)
 
#define FB_CSPMCR_GROUP1_SHIFT   (28U)
 
#define FB_CSPMCR_GROUP1(x)   (((uint32_t)(((uint32_t)(x)) << FB_CSPMCR_GROUP1_SHIFT)) & FB_CSPMCR_GROUP1_MASK)
 
PFAPR - Flash Access Protection Register
#define FMC_PFAPR_M0AP_MASK   (0x3U)
 
#define FMC_PFAPR_M0AP_SHIFT   (0U)
 
#define FMC_PFAPR_M0AP(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFAPR_M0AP_SHIFT)) & FMC_PFAPR_M0AP_MASK)
 
#define FMC_PFAPR_M1AP_MASK   (0xCU)
 
#define FMC_PFAPR_M1AP_SHIFT   (2U)
 
#define FMC_PFAPR_M1AP(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFAPR_M1AP_SHIFT)) & FMC_PFAPR_M1AP_MASK)
 
#define FMC_PFAPR_M2AP_MASK   (0x30U)
 
#define FMC_PFAPR_M2AP_SHIFT   (4U)
 
#define FMC_PFAPR_M2AP(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFAPR_M2AP_SHIFT)) & FMC_PFAPR_M2AP_MASK)
 
#define FMC_PFAPR_M3AP_MASK   (0xC0U)
 
#define FMC_PFAPR_M3AP_SHIFT   (6U)
 
#define FMC_PFAPR_M3AP(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFAPR_M3AP_SHIFT)) & FMC_PFAPR_M3AP_MASK)
 
#define FMC_PFAPR_M4AP_MASK   (0x300U)
 
#define FMC_PFAPR_M4AP_SHIFT   (8U)
 
#define FMC_PFAPR_M4AP(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFAPR_M4AP_SHIFT)) & FMC_PFAPR_M4AP_MASK)
 
#define FMC_PFAPR_M5AP_MASK   (0xC00U)
 
#define FMC_PFAPR_M5AP_SHIFT   (10U)
 
#define FMC_PFAPR_M5AP(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFAPR_M5AP_SHIFT)) & FMC_PFAPR_M5AP_MASK)
 
#define FMC_PFAPR_M6AP_MASK   (0x3000U)
 
#define FMC_PFAPR_M6AP_SHIFT   (12U)
 
#define FMC_PFAPR_M6AP(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFAPR_M6AP_SHIFT)) & FMC_PFAPR_M6AP_MASK)
 
#define FMC_PFAPR_M7AP_MASK   (0xC000U)
 
#define FMC_PFAPR_M7AP_SHIFT   (14U)
 
#define FMC_PFAPR_M7AP(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFAPR_M7AP_SHIFT)) & FMC_PFAPR_M7AP_MASK)
 
#define FMC_PFAPR_M0PFD_MASK   (0x10000U)
 
#define FMC_PFAPR_M0PFD_SHIFT   (16U)
 
#define FMC_PFAPR_M0PFD(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFAPR_M0PFD_SHIFT)) & FMC_PFAPR_M0PFD_MASK)
 
#define FMC_PFAPR_M1PFD_MASK   (0x20000U)
 
#define FMC_PFAPR_M1PFD_SHIFT   (17U)
 
#define FMC_PFAPR_M1PFD(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFAPR_M1PFD_SHIFT)) & FMC_PFAPR_M1PFD_MASK)
 
#define FMC_PFAPR_M2PFD_MASK   (0x40000U)
 
#define FMC_PFAPR_M2PFD_SHIFT   (18U)
 
#define FMC_PFAPR_M2PFD(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFAPR_M2PFD_SHIFT)) & FMC_PFAPR_M2PFD_MASK)
 
#define FMC_PFAPR_M3PFD_MASK   (0x80000U)
 
#define FMC_PFAPR_M3PFD_SHIFT   (19U)
 
#define FMC_PFAPR_M3PFD(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFAPR_M3PFD_SHIFT)) & FMC_PFAPR_M3PFD_MASK)
 
#define FMC_PFAPR_M4PFD_MASK   (0x100000U)
 
#define FMC_PFAPR_M4PFD_SHIFT   (20U)
 
#define FMC_PFAPR_M4PFD(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFAPR_M4PFD_SHIFT)) & FMC_PFAPR_M4PFD_MASK)
 
#define FMC_PFAPR_M5PFD_MASK   (0x200000U)
 
#define FMC_PFAPR_M5PFD_SHIFT   (21U)
 
#define FMC_PFAPR_M5PFD(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFAPR_M5PFD_SHIFT)) & FMC_PFAPR_M5PFD_MASK)
 
#define FMC_PFAPR_M6PFD_MASK   (0x400000U)
 
#define FMC_PFAPR_M6PFD_SHIFT   (22U)
 
#define FMC_PFAPR_M6PFD(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFAPR_M6PFD_SHIFT)) & FMC_PFAPR_M6PFD_MASK)
 
#define FMC_PFAPR_M7PFD_MASK   (0x800000U)
 
#define FMC_PFAPR_M7PFD_SHIFT   (23U)
 
#define FMC_PFAPR_M7PFD(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFAPR_M7PFD_SHIFT)) & FMC_PFAPR_M7PFD_MASK)
 
PFB0CR - Flash Bank 0 Control Register
#define FMC_PFB0CR_B0SEBE_MASK   (0x1U)
 
#define FMC_PFB0CR_B0SEBE_SHIFT   (0U)
 
#define FMC_PFB0CR_B0SEBE(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFB0CR_B0SEBE_SHIFT)) & FMC_PFB0CR_B0SEBE_MASK)
 
#define FMC_PFB0CR_B0IPE_MASK   (0x2U)
 
#define FMC_PFB0CR_B0IPE_SHIFT   (1U)
 
#define FMC_PFB0CR_B0IPE(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFB0CR_B0IPE_SHIFT)) & FMC_PFB0CR_B0IPE_MASK)
 
#define FMC_PFB0CR_B0DPE_MASK   (0x4U)
 
#define FMC_PFB0CR_B0DPE_SHIFT   (2U)
 
#define FMC_PFB0CR_B0DPE(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFB0CR_B0DPE_SHIFT)) & FMC_PFB0CR_B0DPE_MASK)
 
#define FMC_PFB0CR_B0ICE_MASK   (0x8U)
 
#define FMC_PFB0CR_B0ICE_SHIFT   (3U)
 
#define FMC_PFB0CR_B0ICE(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFB0CR_B0ICE_SHIFT)) & FMC_PFB0CR_B0ICE_MASK)
 
#define FMC_PFB0CR_B0DCE_MASK   (0x10U)
 
#define FMC_PFB0CR_B0DCE_SHIFT   (4U)
 
#define FMC_PFB0CR_B0DCE(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFB0CR_B0DCE_SHIFT)) & FMC_PFB0CR_B0DCE_MASK)
 
#define FMC_PFB0CR_CRC_MASK   (0xE0U)
 
#define FMC_PFB0CR_CRC_SHIFT   (5U)
 
#define FMC_PFB0CR_CRC(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFB0CR_CRC_SHIFT)) & FMC_PFB0CR_CRC_MASK)
 
#define FMC_PFB0CR_B0MW_MASK   (0x60000U)
 
#define FMC_PFB0CR_B0MW_SHIFT   (17U)
 
#define FMC_PFB0CR_B0MW(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFB0CR_B0MW_SHIFT)) & FMC_PFB0CR_B0MW_MASK)
 
#define FMC_PFB0CR_S_B_INV_MASK   (0x80000U)
 
#define FMC_PFB0CR_S_B_INV_SHIFT   (19U)
 
#define FMC_PFB0CR_S_B_INV(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFB0CR_S_B_INV_SHIFT)) & FMC_PFB0CR_S_B_INV_MASK)
 
#define FMC_PFB0CR_CINV_WAY_MASK   (0xF00000U)
 
#define FMC_PFB0CR_CINV_WAY_SHIFT   (20U)
 
#define FMC_PFB0CR_CINV_WAY(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFB0CR_CINV_WAY_SHIFT)) & FMC_PFB0CR_CINV_WAY_MASK)
 
#define FMC_PFB0CR_CLCK_WAY_MASK   (0xF000000U)
 
#define FMC_PFB0CR_CLCK_WAY_SHIFT   (24U)
 
#define FMC_PFB0CR_CLCK_WAY(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFB0CR_CLCK_WAY_SHIFT)) & FMC_PFB0CR_CLCK_WAY_MASK)
 
#define FMC_PFB0CR_B0RWSC_MASK   (0xF0000000U)
 
#define FMC_PFB0CR_B0RWSC_SHIFT   (28U)
 
#define FMC_PFB0CR_B0RWSC(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFB0CR_B0RWSC_SHIFT)) & FMC_PFB0CR_B0RWSC_MASK)
 
PFB1CR - Flash Bank 1 Control Register
#define FMC_PFB1CR_B1SEBE_MASK   (0x1U)
 
#define FMC_PFB1CR_B1SEBE_SHIFT   (0U)
 
#define FMC_PFB1CR_B1SEBE(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFB1CR_B1SEBE_SHIFT)) & FMC_PFB1CR_B1SEBE_MASK)
 
#define FMC_PFB1CR_B1IPE_MASK   (0x2U)
 
#define FMC_PFB1CR_B1IPE_SHIFT   (1U)
 
#define FMC_PFB1CR_B1IPE(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFB1CR_B1IPE_SHIFT)) & FMC_PFB1CR_B1IPE_MASK)
 
#define FMC_PFB1CR_B1DPE_MASK   (0x4U)
 
#define FMC_PFB1CR_B1DPE_SHIFT   (2U)
 
#define FMC_PFB1CR_B1DPE(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFB1CR_B1DPE_SHIFT)) & FMC_PFB1CR_B1DPE_MASK)
 
#define FMC_PFB1CR_B1ICE_MASK   (0x8U)
 
#define FMC_PFB1CR_B1ICE_SHIFT   (3U)
 
#define FMC_PFB1CR_B1ICE(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFB1CR_B1ICE_SHIFT)) & FMC_PFB1CR_B1ICE_MASK)
 
#define FMC_PFB1CR_B1DCE_MASK   (0x10U)
 
#define FMC_PFB1CR_B1DCE_SHIFT   (4U)
 
#define FMC_PFB1CR_B1DCE(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFB1CR_B1DCE_SHIFT)) & FMC_PFB1CR_B1DCE_MASK)
 
#define FMC_PFB1CR_B1MW_MASK   (0x60000U)
 
#define FMC_PFB1CR_B1MW_SHIFT   (17U)
 
#define FMC_PFB1CR_B1MW(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFB1CR_B1MW_SHIFT)) & FMC_PFB1CR_B1MW_MASK)
 
#define FMC_PFB1CR_B1RWSC_MASK   (0xF0000000U)
 
#define FMC_PFB1CR_B1RWSC_SHIFT   (28U)
 
#define FMC_PFB1CR_B1RWSC(x)   (((uint32_t)(((uint32_t)(x)) << FMC_PFB1CR_B1RWSC_SHIFT)) & FMC_PFB1CR_B1RWSC_MASK)
 
TAGVDW0S - Cache Tag Storage
#define FMC_TAGVDW0S_valid_MASK   (0x1U)
 
#define FMC_TAGVDW0S_valid_SHIFT   (0U)
 
#define FMC_TAGVDW0S_valid(x)   (((uint32_t)(((uint32_t)(x)) << FMC_TAGVDW0S_valid_SHIFT)) & FMC_TAGVDW0S_valid_MASK)
 
#define FMC_TAGVDW0S_tag_MASK   (0x7FFE0U)
 
#define FMC_TAGVDW0S_tag_SHIFT   (5U)
 
#define FMC_TAGVDW0S_tag(x)   (((uint32_t)(((uint32_t)(x)) << FMC_TAGVDW0S_tag_SHIFT)) & FMC_TAGVDW0S_tag_MASK)
 
#define FMC_TAGVDW0S_COUNT   (4U)
 
TAGVDW1S - Cache Tag Storage
#define FMC_TAGVDW1S_valid_MASK   (0x1U)
 
#define FMC_TAGVDW1S_valid_SHIFT   (0U)
 
#define FMC_TAGVDW1S_valid(x)   (((uint32_t)(((uint32_t)(x)) << FMC_TAGVDW1S_valid_SHIFT)) & FMC_TAGVDW1S_valid_MASK)
 
#define FMC_TAGVDW1S_tag_MASK   (0x7FFE0U)
 
#define FMC_TAGVDW1S_tag_SHIFT   (5U)
 
#define FMC_TAGVDW1S_tag(x)   (((uint32_t)(((uint32_t)(x)) << FMC_TAGVDW1S_tag_SHIFT)) & FMC_TAGVDW1S_tag_MASK)
 
#define FMC_TAGVDW1S_COUNT   (4U)
 
TAGVDW2S - Cache Tag Storage
#define FMC_TAGVDW2S_valid_MASK   (0x1U)
 
#define FMC_TAGVDW2S_valid_SHIFT   (0U)
 
#define FMC_TAGVDW2S_valid(x)   (((uint32_t)(((uint32_t)(x)) << FMC_TAGVDW2S_valid_SHIFT)) & FMC_TAGVDW2S_valid_MASK)
 
#define FMC_TAGVDW2S_tag_MASK   (0x7FFE0U)
 
#define FMC_TAGVDW2S_tag_SHIFT   (5U)
 
#define FMC_TAGVDW2S_tag(x)   (((uint32_t)(((uint32_t)(x)) << FMC_TAGVDW2S_tag_SHIFT)) & FMC_TAGVDW2S_tag_MASK)
 
#define FMC_TAGVDW2S_COUNT   (4U)
 
TAGVDW3S - Cache Tag Storage
#define FMC_TAGVDW3S_valid_MASK   (0x1U)
 
#define FMC_TAGVDW3S_valid_SHIFT   (0U)
 
#define FMC_TAGVDW3S_valid(x)   (((uint32_t)(((uint32_t)(x)) << FMC_TAGVDW3S_valid_SHIFT)) & FMC_TAGVDW3S_valid_MASK)
 
#define FMC_TAGVDW3S_tag_MASK   (0x7FFE0U)
 
#define FMC_TAGVDW3S_tag_SHIFT   (5U)
 
#define FMC_TAGVDW3S_tag(x)   (((uint32_t)(((uint32_t)(x)) << FMC_TAGVDW3S_tag_SHIFT)) & FMC_TAGVDW3S_tag_MASK)
 
#define FMC_TAGVDW3S_COUNT   (4U)
 
DATA_U - Cache Data Storage (upper word)
#define FMC_DATA_U_data_MASK   (0xFFFFFFFFU)
 
#define FMC_DATA_U_data_SHIFT   (0U)
 
#define FMC_DATA_U_data(x)   (((uint32_t)(((uint32_t)(x)) << FMC_DATA_U_data_SHIFT)) & FMC_DATA_U_data_MASK)
 
#define FMC_DATA_U_COUNT   (4U)
 
#define FMC_DATA_U_COUNT2   (4U)
 
DATA_L - Cache Data Storage (lower word)
#define FMC_DATA_L_data_MASK   (0xFFFFFFFFU)
 
#define FMC_DATA_L_data_SHIFT   (0U)
 
#define FMC_DATA_L_data(x)   (((uint32_t)(((uint32_t)(x)) << FMC_DATA_L_data_SHIFT)) & FMC_DATA_L_data_MASK)
 
#define FMC_DATA_L_COUNT   (4U)
 
#define FMC_DATA_L_COUNT2   (4U)
 
FSTAT - Flash Status Register
#define FTFE_FSTAT_MGSTAT0_MASK   (0x1U)
 
#define FTFE_FSTAT_MGSTAT0_SHIFT   (0U)
 
#define FTFE_FSTAT_MGSTAT0(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FSTAT_MGSTAT0_SHIFT)) & FTFE_FSTAT_MGSTAT0_MASK)
 
#define FTFE_FSTAT_FPVIOL_MASK   (0x10U)
 
#define FTFE_FSTAT_FPVIOL_SHIFT   (4U)
 
#define FTFE_FSTAT_FPVIOL(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FSTAT_FPVIOL_SHIFT)) & FTFE_FSTAT_FPVIOL_MASK)
 
#define FTFE_FSTAT_ACCERR_MASK   (0x20U)
 
#define FTFE_FSTAT_ACCERR_SHIFT   (5U)
 
#define FTFE_FSTAT_ACCERR(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FSTAT_ACCERR_SHIFT)) & FTFE_FSTAT_ACCERR_MASK)
 
#define FTFE_FSTAT_RDCOLERR_MASK   (0x40U)
 
#define FTFE_FSTAT_RDCOLERR_SHIFT   (6U)
 
#define FTFE_FSTAT_RDCOLERR(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FSTAT_RDCOLERR_SHIFT)) & FTFE_FSTAT_RDCOLERR_MASK)
 
#define FTFE_FSTAT_CCIF_MASK   (0x80U)
 
#define FTFE_FSTAT_CCIF_SHIFT   (7U)
 
#define FTFE_FSTAT_CCIF(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FSTAT_CCIF_SHIFT)) & FTFE_FSTAT_CCIF_MASK)
 
FCNFG - Flash Configuration Register
#define FTFE_FCNFG_EEERDY_MASK   (0x1U)
 
#define FTFE_FCNFG_EEERDY_SHIFT   (0U)
 
#define FTFE_FCNFG_EEERDY(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FCNFG_EEERDY_SHIFT)) & FTFE_FCNFG_EEERDY_MASK)
 
#define FTFE_FCNFG_RAMRDY_MASK   (0x2U)
 
#define FTFE_FCNFG_RAMRDY_SHIFT   (1U)
 
#define FTFE_FCNFG_RAMRDY(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FCNFG_RAMRDY_SHIFT)) & FTFE_FCNFG_RAMRDY_MASK)
 
#define FTFE_FCNFG_PFLSH_MASK   (0x4U)
 
#define FTFE_FCNFG_PFLSH_SHIFT   (2U)
 
#define FTFE_FCNFG_PFLSH(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FCNFG_PFLSH_SHIFT)) & FTFE_FCNFG_PFLSH_MASK)
 
#define FTFE_FCNFG_SWAP_MASK   (0x8U)
 
#define FTFE_FCNFG_SWAP_SHIFT   (3U)
 
#define FTFE_FCNFG_SWAP(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FCNFG_SWAP_SHIFT)) & FTFE_FCNFG_SWAP_MASK)
 
#define FTFE_FCNFG_ERSSUSP_MASK   (0x10U)
 
#define FTFE_FCNFG_ERSSUSP_SHIFT   (4U)
 
#define FTFE_FCNFG_ERSSUSP(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FCNFG_ERSSUSP_SHIFT)) & FTFE_FCNFG_ERSSUSP_MASK)
 
#define FTFE_FCNFG_ERSAREQ_MASK   (0x20U)
 
#define FTFE_FCNFG_ERSAREQ_SHIFT   (5U)
 
#define FTFE_FCNFG_ERSAREQ(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FCNFG_ERSAREQ_SHIFT)) & FTFE_FCNFG_ERSAREQ_MASK)
 
#define FTFE_FCNFG_RDCOLLIE_MASK   (0x40U)
 
#define FTFE_FCNFG_RDCOLLIE_SHIFT   (6U)
 
#define FTFE_FCNFG_RDCOLLIE(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FCNFG_RDCOLLIE_SHIFT)) & FTFE_FCNFG_RDCOLLIE_MASK)
 
#define FTFE_FCNFG_CCIE_MASK   (0x80U)
 
#define FTFE_FCNFG_CCIE_SHIFT   (7U)
 
#define FTFE_FCNFG_CCIE(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FCNFG_CCIE_SHIFT)) & FTFE_FCNFG_CCIE_MASK)
 
FSEC - Flash Security Register
#define FTFE_FSEC_SEC_MASK   (0x3U)
 
#define FTFE_FSEC_SEC_SHIFT   (0U)
 
#define FTFE_FSEC_SEC(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FSEC_SEC_SHIFT)) & FTFE_FSEC_SEC_MASK)
 
#define FTFE_FSEC_FSLACC_MASK   (0xCU)
 
#define FTFE_FSEC_FSLACC_SHIFT   (2U)
 
#define FTFE_FSEC_FSLACC(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FSEC_FSLACC_SHIFT)) & FTFE_FSEC_FSLACC_MASK)
 
#define FTFE_FSEC_MEEN_MASK   (0x30U)
 
#define FTFE_FSEC_MEEN_SHIFT   (4U)
 
#define FTFE_FSEC_MEEN(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FSEC_MEEN_SHIFT)) & FTFE_FSEC_MEEN_MASK)
 
#define FTFE_FSEC_KEYEN_MASK   (0xC0U)
 
#define FTFE_FSEC_KEYEN_SHIFT   (6U)
 
#define FTFE_FSEC_KEYEN(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FSEC_KEYEN_SHIFT)) & FTFE_FSEC_KEYEN_MASK)
 
FOPT - Flash Option Register
#define FTFE_FOPT_OPT_MASK   (0xFFU)
 
#define FTFE_FOPT_OPT_SHIFT   (0U)
 
#define FTFE_FOPT_OPT(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FOPT_OPT_SHIFT)) & FTFE_FOPT_OPT_MASK)
 
FCCOB3 - Flash Common Command Object Registers
#define FTFE_FCCOB3_CCOBn_MASK   (0xFFU)
 
#define FTFE_FCCOB3_CCOBn_SHIFT   (0U)
 
#define FTFE_FCCOB3_CCOBn(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FCCOB3_CCOBn_SHIFT)) & FTFE_FCCOB3_CCOBn_MASK)
 
FCCOB2 - Flash Common Command Object Registers
#define FTFE_FCCOB2_CCOBn_MASK   (0xFFU)
 
#define FTFE_FCCOB2_CCOBn_SHIFT   (0U)
 
#define FTFE_FCCOB2_CCOBn(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FCCOB2_CCOBn_SHIFT)) & FTFE_FCCOB2_CCOBn_MASK)
 
FCCOB1 - Flash Common Command Object Registers
#define FTFE_FCCOB1_CCOBn_MASK   (0xFFU)
 
#define FTFE_FCCOB1_CCOBn_SHIFT   (0U)
 
#define FTFE_FCCOB1_CCOBn(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FCCOB1_CCOBn_SHIFT)) & FTFE_FCCOB1_CCOBn_MASK)
 
FCCOB0 - Flash Common Command Object Registers
#define FTFE_FCCOB0_CCOBn_MASK   (0xFFU)
 
#define FTFE_FCCOB0_CCOBn_SHIFT   (0U)
 
#define FTFE_FCCOB0_CCOBn(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FCCOB0_CCOBn_SHIFT)) & FTFE_FCCOB0_CCOBn_MASK)
 
FCCOB7 - Flash Common Command Object Registers
#define FTFE_FCCOB7_CCOBn_MASK   (0xFFU)
 
#define FTFE_FCCOB7_CCOBn_SHIFT   (0U)
 
#define FTFE_FCCOB7_CCOBn(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FCCOB7_CCOBn_SHIFT)) & FTFE_FCCOB7_CCOBn_MASK)
 
FCCOB6 - Flash Common Command Object Registers
#define FTFE_FCCOB6_CCOBn_MASK   (0xFFU)
 
#define FTFE_FCCOB6_CCOBn_SHIFT   (0U)
 
#define FTFE_FCCOB6_CCOBn(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FCCOB6_CCOBn_SHIFT)) & FTFE_FCCOB6_CCOBn_MASK)
 
FCCOB5 - Flash Common Command Object Registers
#define FTFE_FCCOB5_CCOBn_MASK   (0xFFU)
 
#define FTFE_FCCOB5_CCOBn_SHIFT   (0U)
 
#define FTFE_FCCOB5_CCOBn(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FCCOB5_CCOBn_SHIFT)) & FTFE_FCCOB5_CCOBn_MASK)
 
FCCOB4 - Flash Common Command Object Registers
#define FTFE_FCCOB4_CCOBn_MASK   (0xFFU)
 
#define FTFE_FCCOB4_CCOBn_SHIFT   (0U)
 
#define FTFE_FCCOB4_CCOBn(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FCCOB4_CCOBn_SHIFT)) & FTFE_FCCOB4_CCOBn_MASK)
 
FCCOBB - Flash Common Command Object Registers
#define FTFE_FCCOBB_CCOBn_MASK   (0xFFU)
 
#define FTFE_FCCOBB_CCOBn_SHIFT   (0U)
 
#define FTFE_FCCOBB_CCOBn(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FCCOBB_CCOBn_SHIFT)) & FTFE_FCCOBB_CCOBn_MASK)
 
FCCOBA - Flash Common Command Object Registers
#define FTFE_FCCOBA_CCOBn_MASK   (0xFFU)
 
#define FTFE_FCCOBA_CCOBn_SHIFT   (0U)
 
#define FTFE_FCCOBA_CCOBn(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FCCOBA_CCOBn_SHIFT)) & FTFE_FCCOBA_CCOBn_MASK)
 
FCCOB9 - Flash Common Command Object Registers
#define FTFE_FCCOB9_CCOBn_MASK   (0xFFU)
 
#define FTFE_FCCOB9_CCOBn_SHIFT   (0U)
 
#define FTFE_FCCOB9_CCOBn(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FCCOB9_CCOBn_SHIFT)) & FTFE_FCCOB9_CCOBn_MASK)
 
FCCOB8 - Flash Common Command Object Registers
#define FTFE_FCCOB8_CCOBn_MASK   (0xFFU)
 
#define FTFE_FCCOB8_CCOBn_SHIFT   (0U)
 
#define FTFE_FCCOB8_CCOBn(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FCCOB8_CCOBn_SHIFT)) & FTFE_FCCOB8_CCOBn_MASK)
 
FPROT3 - Program Flash Protection Registers
#define FTFE_FPROT3_PROT_MASK   (0xFFU)
 
#define FTFE_FPROT3_PROT_SHIFT   (0U)
 
#define FTFE_FPROT3_PROT(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FPROT3_PROT_SHIFT)) & FTFE_FPROT3_PROT_MASK)
 
FPROT2 - Program Flash Protection Registers
#define FTFE_FPROT2_PROT_MASK   (0xFFU)
 
#define FTFE_FPROT2_PROT_SHIFT   (0U)
 
#define FTFE_FPROT2_PROT(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FPROT2_PROT_SHIFT)) & FTFE_FPROT2_PROT_MASK)
 
FPROT1 - Program Flash Protection Registers
#define FTFE_FPROT1_PROT_MASK   (0xFFU)
 
#define FTFE_FPROT1_PROT_SHIFT   (0U)
 
#define FTFE_FPROT1_PROT(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FPROT1_PROT_SHIFT)) & FTFE_FPROT1_PROT_MASK)
 
FPROT0 - Program Flash Protection Registers
#define FTFE_FPROT0_PROT_MASK   (0xFFU)
 
#define FTFE_FPROT0_PROT_SHIFT   (0U)
 
#define FTFE_FPROT0_PROT(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FPROT0_PROT_SHIFT)) & FTFE_FPROT0_PROT_MASK)
 
FEPROT - EEPROM Protection Register
#define FTFE_FEPROT_EPROT_MASK   (0xFFU)
 
#define FTFE_FEPROT_EPROT_SHIFT   (0U)
 
#define FTFE_FEPROT_EPROT(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FEPROT_EPROT_SHIFT)) & FTFE_FEPROT_EPROT_MASK)
 
FDPROT - Data Flash Protection Register
#define FTFE_FDPROT_DPROT_MASK   (0xFFU)
 
#define FTFE_FDPROT_DPROT_SHIFT   (0U)
 
#define FTFE_FDPROT_DPROT(x)   (((uint8_t)(((uint8_t)(x)) << FTFE_FDPROT_DPROT_SHIFT)) & FTFE_FDPROT_DPROT_MASK)
 
SC - Status And Control
#define FTM_SC_PS_MASK   (0x7U)
 
#define FTM_SC_PS_SHIFT   (0U)
 
#define FTM_SC_PS(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SC_PS_SHIFT)) & FTM_SC_PS_MASK)
 
#define FTM_SC_CLKS_MASK   (0x18U)
 
#define FTM_SC_CLKS_SHIFT   (3U)
 
#define FTM_SC_CLKS(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SC_CLKS_SHIFT)) & FTM_SC_CLKS_MASK)
 
#define FTM_SC_CPWMS_MASK   (0x20U)
 
#define FTM_SC_CPWMS_SHIFT   (5U)
 
#define FTM_SC_CPWMS(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SC_CPWMS_SHIFT)) & FTM_SC_CPWMS_MASK)
 
#define FTM_SC_TOIE_MASK   (0x40U)
 
#define FTM_SC_TOIE_SHIFT   (6U)
 
#define FTM_SC_TOIE(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SC_TOIE_SHIFT)) & FTM_SC_TOIE_MASK)
 
#define FTM_SC_TOF_MASK   (0x80U)
 
#define FTM_SC_TOF_SHIFT   (7U)
 
#define FTM_SC_TOF(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SC_TOF_SHIFT)) & FTM_SC_TOF_MASK)
 
CNT - Counter
#define FTM_CNT_COUNT_MASK   (0xFFFFU)
 
#define FTM_CNT_COUNT_SHIFT   (0U)
 
#define FTM_CNT_COUNT(x)   (((uint32_t)(((uint32_t)(x)) << FTM_CNT_COUNT_SHIFT)) & FTM_CNT_COUNT_MASK)
 
MOD - Modulo
#define FTM_MOD_MOD_MASK   (0xFFFFU)
 
#define FTM_MOD_MOD_SHIFT   (0U)
 
#define FTM_MOD_MOD(x)   (((uint32_t)(((uint32_t)(x)) << FTM_MOD_MOD_SHIFT)) & FTM_MOD_MOD_MASK)
 
CnSC - Channel (n) Status And Control
#define FTM_CnSC_DMA_MASK   (0x1U)
 
#define FTM_CnSC_DMA_SHIFT   (0U)
 
#define FTM_CnSC_DMA(x)   (((uint32_t)(((uint32_t)(x)) << FTM_CnSC_DMA_SHIFT)) & FTM_CnSC_DMA_MASK)
 
#define FTM_CnSC_ELSA_MASK   (0x4U)
 
#define FTM_CnSC_ELSA_SHIFT   (2U)
 
#define FTM_CnSC_ELSA(x)   (((uint32_t)(((uint32_t)(x)) << FTM_CnSC_ELSA_SHIFT)) & FTM_CnSC_ELSA_MASK)
 
#define FTM_CnSC_ELSB_MASK   (0x8U)
 
#define FTM_CnSC_ELSB_SHIFT   (3U)
 
#define FTM_CnSC_ELSB(x)   (((uint32_t)(((uint32_t)(x)) << FTM_CnSC_ELSB_SHIFT)) & FTM_CnSC_ELSB_MASK)
 
#define FTM_CnSC_MSA_MASK   (0x10U)
 
#define FTM_CnSC_MSA_SHIFT   (4U)
 
#define FTM_CnSC_MSA(x)   (((uint32_t)(((uint32_t)(x)) << FTM_CnSC_MSA_SHIFT)) & FTM_CnSC_MSA_MASK)
 
#define FTM_CnSC_MSB_MASK   (0x20U)
 
#define FTM_CnSC_MSB_SHIFT   (5U)
 
#define FTM_CnSC_MSB(x)   (((uint32_t)(((uint32_t)(x)) << FTM_CnSC_MSB_SHIFT)) & FTM_CnSC_MSB_MASK)
 
#define FTM_CnSC_CHIE_MASK   (0x40U)
 
#define FTM_CnSC_CHIE_SHIFT   (6U)
 
#define FTM_CnSC_CHIE(x)   (((uint32_t)(((uint32_t)(x)) << FTM_CnSC_CHIE_SHIFT)) & FTM_CnSC_CHIE_MASK)
 
#define FTM_CnSC_CHF_MASK   (0x80U)
 
#define FTM_CnSC_CHF_SHIFT   (7U)
 
#define FTM_CnSC_CHF(x)   (((uint32_t)(((uint32_t)(x)) << FTM_CnSC_CHF_SHIFT)) & FTM_CnSC_CHF_MASK)
 
#define FTM_CnSC_COUNT   (8U)
 
CnV - Channel (n) Value
#define FTM_CnV_VAL_MASK   (0xFFFFU)
 
#define FTM_CnV_VAL_SHIFT   (0U)
 
#define FTM_CnV_VAL(x)   (((uint32_t)(((uint32_t)(x)) << FTM_CnV_VAL_SHIFT)) & FTM_CnV_VAL_MASK)
 
#define FTM_CnV_COUNT   (8U)
 
CNTIN - Counter Initial Value
#define FTM_CNTIN_INIT_MASK   (0xFFFFU)
 
#define FTM_CNTIN_INIT_SHIFT   (0U)
 
#define FTM_CNTIN_INIT(x)   (((uint32_t)(((uint32_t)(x)) << FTM_CNTIN_INIT_SHIFT)) & FTM_CNTIN_INIT_MASK)
 
STATUS - Capture And Compare Status
#define FTM_STATUS_CH0F_MASK   (0x1U)
 
#define FTM_STATUS_CH0F_SHIFT   (0U)
 
#define FTM_STATUS_CH0F(x)   (((uint32_t)(((uint32_t)(x)) << FTM_STATUS_CH0F_SHIFT)) & FTM_STATUS_CH0F_MASK)
 
#define FTM_STATUS_CH1F_MASK   (0x2U)
 
#define FTM_STATUS_CH1F_SHIFT   (1U)
 
#define FTM_STATUS_CH1F(x)   (((uint32_t)(((uint32_t)(x)) << FTM_STATUS_CH1F_SHIFT)) & FTM_STATUS_CH1F_MASK)
 
#define FTM_STATUS_CH2F_MASK   (0x4U)
 
#define FTM_STATUS_CH2F_SHIFT   (2U)
 
#define FTM_STATUS_CH2F(x)   (((uint32_t)(((uint32_t)(x)) << FTM_STATUS_CH2F_SHIFT)) & FTM_STATUS_CH2F_MASK)
 
#define FTM_STATUS_CH3F_MASK   (0x8U)
 
#define FTM_STATUS_CH3F_SHIFT   (3U)
 
#define FTM_STATUS_CH3F(x)   (((uint32_t)(((uint32_t)(x)) << FTM_STATUS_CH3F_SHIFT)) & FTM_STATUS_CH3F_MASK)
 
#define FTM_STATUS_CH4F_MASK   (0x10U)
 
#define FTM_STATUS_CH4F_SHIFT   (4U)
 
#define FTM_STATUS_CH4F(x)   (((uint32_t)(((uint32_t)(x)) << FTM_STATUS_CH4F_SHIFT)) & FTM_STATUS_CH4F_MASK)
 
#define FTM_STATUS_CH5F_MASK   (0x20U)
 
#define FTM_STATUS_CH5F_SHIFT   (5U)
 
#define FTM_STATUS_CH5F(x)   (((uint32_t)(((uint32_t)(x)) << FTM_STATUS_CH5F_SHIFT)) & FTM_STATUS_CH5F_MASK)
 
#define FTM_STATUS_CH6F_MASK   (0x40U)
 
#define FTM_STATUS_CH6F_SHIFT   (6U)
 
#define FTM_STATUS_CH6F(x)   (((uint32_t)(((uint32_t)(x)) << FTM_STATUS_CH6F_SHIFT)) & FTM_STATUS_CH6F_MASK)
 
#define FTM_STATUS_CH7F_MASK   (0x80U)
 
#define FTM_STATUS_CH7F_SHIFT   (7U)
 
#define FTM_STATUS_CH7F(x)   (((uint32_t)(((uint32_t)(x)) << FTM_STATUS_CH7F_SHIFT)) & FTM_STATUS_CH7F_MASK)
 
MODE - Features Mode Selection
#define FTM_MODE_FTMEN_MASK   (0x1U)
 
#define FTM_MODE_FTMEN_SHIFT   (0U)
 
#define FTM_MODE_FTMEN(x)   (((uint32_t)(((uint32_t)(x)) << FTM_MODE_FTMEN_SHIFT)) & FTM_MODE_FTMEN_MASK)
 
#define FTM_MODE_INIT_MASK   (0x2U)
 
#define FTM_MODE_INIT_SHIFT   (1U)
 
#define FTM_MODE_INIT(x)   (((uint32_t)(((uint32_t)(x)) << FTM_MODE_INIT_SHIFT)) & FTM_MODE_INIT_MASK)
 
#define FTM_MODE_WPDIS_MASK   (0x4U)
 
#define FTM_MODE_WPDIS_SHIFT   (2U)
 
#define FTM_MODE_WPDIS(x)   (((uint32_t)(((uint32_t)(x)) << FTM_MODE_WPDIS_SHIFT)) & FTM_MODE_WPDIS_MASK)
 
#define FTM_MODE_PWMSYNC_MASK   (0x8U)
 
#define FTM_MODE_PWMSYNC_SHIFT   (3U)
 
#define FTM_MODE_PWMSYNC(x)   (((uint32_t)(((uint32_t)(x)) << FTM_MODE_PWMSYNC_SHIFT)) & FTM_MODE_PWMSYNC_MASK)
 
#define FTM_MODE_CAPTEST_MASK   (0x10U)
 
#define FTM_MODE_CAPTEST_SHIFT   (4U)
 
#define FTM_MODE_CAPTEST(x)   (((uint32_t)(((uint32_t)(x)) << FTM_MODE_CAPTEST_SHIFT)) & FTM_MODE_CAPTEST_MASK)
 
#define FTM_MODE_FAULTM_MASK   (0x60U)
 
#define FTM_MODE_FAULTM_SHIFT   (5U)
 
#define FTM_MODE_FAULTM(x)   (((uint32_t)(((uint32_t)(x)) << FTM_MODE_FAULTM_SHIFT)) & FTM_MODE_FAULTM_MASK)
 
#define FTM_MODE_FAULTIE_MASK   (0x80U)
 
#define FTM_MODE_FAULTIE_SHIFT   (7U)
 
#define FTM_MODE_FAULTIE(x)   (((uint32_t)(((uint32_t)(x)) << FTM_MODE_FAULTIE_SHIFT)) & FTM_MODE_FAULTIE_MASK)
 
SYNC - Synchronization
#define FTM_SYNC_CNTMIN_MASK   (0x1U)
 
#define FTM_SYNC_CNTMIN_SHIFT   (0U)
 
#define FTM_SYNC_CNTMIN(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SYNC_CNTMIN_SHIFT)) & FTM_SYNC_CNTMIN_MASK)
 
#define FTM_SYNC_CNTMAX_MASK   (0x2U)
 
#define FTM_SYNC_CNTMAX_SHIFT   (1U)
 
#define FTM_SYNC_CNTMAX(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SYNC_CNTMAX_SHIFT)) & FTM_SYNC_CNTMAX_MASK)
 
#define FTM_SYNC_REINIT_MASK   (0x4U)
 
#define FTM_SYNC_REINIT_SHIFT   (2U)
 
#define FTM_SYNC_REINIT(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SYNC_REINIT_SHIFT)) & FTM_SYNC_REINIT_MASK)
 
#define FTM_SYNC_SYNCHOM_MASK   (0x8U)
 
#define FTM_SYNC_SYNCHOM_SHIFT   (3U)
 
#define FTM_SYNC_SYNCHOM(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SYNC_SYNCHOM_SHIFT)) & FTM_SYNC_SYNCHOM_MASK)
 
#define FTM_SYNC_TRIG0_MASK   (0x10U)
 
#define FTM_SYNC_TRIG0_SHIFT   (4U)
 
#define FTM_SYNC_TRIG0(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SYNC_TRIG0_SHIFT)) & FTM_SYNC_TRIG0_MASK)
 
#define FTM_SYNC_TRIG1_MASK   (0x20U)
 
#define FTM_SYNC_TRIG1_SHIFT   (5U)
 
#define FTM_SYNC_TRIG1(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SYNC_TRIG1_SHIFT)) & FTM_SYNC_TRIG1_MASK)
 
#define FTM_SYNC_TRIG2_MASK   (0x40U)
 
#define FTM_SYNC_TRIG2_SHIFT   (6U)
 
#define FTM_SYNC_TRIG2(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SYNC_TRIG2_SHIFT)) & FTM_SYNC_TRIG2_MASK)
 
#define FTM_SYNC_SWSYNC_MASK   (0x80U)
 
#define FTM_SYNC_SWSYNC_SHIFT   (7U)
 
#define FTM_SYNC_SWSYNC(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SYNC_SWSYNC_SHIFT)) & FTM_SYNC_SWSYNC_MASK)
 
OUTINIT - Initial State For Channels Output
#define FTM_OUTINIT_CH0OI_MASK   (0x1U)
 
#define FTM_OUTINIT_CH0OI_SHIFT   (0U)
 
#define FTM_OUTINIT_CH0OI(x)   (((uint32_t)(((uint32_t)(x)) << FTM_OUTINIT_CH0OI_SHIFT)) & FTM_OUTINIT_CH0OI_MASK)
 
#define FTM_OUTINIT_CH1OI_MASK   (0x2U)
 
#define FTM_OUTINIT_CH1OI_SHIFT   (1U)
 
#define FTM_OUTINIT_CH1OI(x)   (((uint32_t)(((uint32_t)(x)) << FTM_OUTINIT_CH1OI_SHIFT)) & FTM_OUTINIT_CH1OI_MASK)
 
#define FTM_OUTINIT_CH2OI_MASK   (0x4U)
 
#define FTM_OUTINIT_CH2OI_SHIFT   (2U)
 
#define FTM_OUTINIT_CH2OI(x)   (((uint32_t)(((uint32_t)(x)) << FTM_OUTINIT_CH2OI_SHIFT)) & FTM_OUTINIT_CH2OI_MASK)
 
#define FTM_OUTINIT_CH3OI_MASK   (0x8U)
 
#define FTM_OUTINIT_CH3OI_SHIFT   (3U)
 
#define FTM_OUTINIT_CH3OI(x)   (((uint32_t)(((uint32_t)(x)) << FTM_OUTINIT_CH3OI_SHIFT)) & FTM_OUTINIT_CH3OI_MASK)
 
#define FTM_OUTINIT_CH4OI_MASK   (0x10U)
 
#define FTM_OUTINIT_CH4OI_SHIFT   (4U)
 
#define FTM_OUTINIT_CH4OI(x)   (((uint32_t)(((uint32_t)(x)) << FTM_OUTINIT_CH4OI_SHIFT)) & FTM_OUTINIT_CH4OI_MASK)
 
#define FTM_OUTINIT_CH5OI_MASK   (0x20U)
 
#define FTM_OUTINIT_CH5OI_SHIFT   (5U)
 
#define FTM_OUTINIT_CH5OI(x)   (((uint32_t)(((uint32_t)(x)) << FTM_OUTINIT_CH5OI_SHIFT)) & FTM_OUTINIT_CH5OI_MASK)
 
#define FTM_OUTINIT_CH6OI_MASK   (0x40U)
 
#define FTM_OUTINIT_CH6OI_SHIFT   (6U)
 
#define FTM_OUTINIT_CH6OI(x)   (((uint32_t)(((uint32_t)(x)) << FTM_OUTINIT_CH6OI_SHIFT)) & FTM_OUTINIT_CH6OI_MASK)
 
#define FTM_OUTINIT_CH7OI_MASK   (0x80U)
 
#define FTM_OUTINIT_CH7OI_SHIFT   (7U)
 
#define FTM_OUTINIT_CH7OI(x)   (((uint32_t)(((uint32_t)(x)) << FTM_OUTINIT_CH7OI_SHIFT)) & FTM_OUTINIT_CH7OI_MASK)
 
OUTMASK - Output Mask
#define FTM_OUTMASK_CH0OM_MASK   (0x1U)
 
#define FTM_OUTMASK_CH0OM_SHIFT   (0U)
 
#define FTM_OUTMASK_CH0OM(x)   (((uint32_t)(((uint32_t)(x)) << FTM_OUTMASK_CH0OM_SHIFT)) & FTM_OUTMASK_CH0OM_MASK)
 
#define FTM_OUTMASK_CH1OM_MASK   (0x2U)
 
#define FTM_OUTMASK_CH1OM_SHIFT   (1U)
 
#define FTM_OUTMASK_CH1OM(x)   (((uint32_t)(((uint32_t)(x)) << FTM_OUTMASK_CH1OM_SHIFT)) & FTM_OUTMASK_CH1OM_MASK)
 
#define FTM_OUTMASK_CH2OM_MASK   (0x4U)
 
#define FTM_OUTMASK_CH2OM_SHIFT   (2U)
 
#define FTM_OUTMASK_CH2OM(x)   (((uint32_t)(((uint32_t)(x)) << FTM_OUTMASK_CH2OM_SHIFT)) & FTM_OUTMASK_CH2OM_MASK)
 
#define FTM_OUTMASK_CH3OM_MASK   (0x8U)
 
#define FTM_OUTMASK_CH3OM_SHIFT   (3U)
 
#define FTM_OUTMASK_CH3OM(x)   (((uint32_t)(((uint32_t)(x)) << FTM_OUTMASK_CH3OM_SHIFT)) & FTM_OUTMASK_CH3OM_MASK)
 
#define FTM_OUTMASK_CH4OM_MASK   (0x10U)
 
#define FTM_OUTMASK_CH4OM_SHIFT   (4U)
 
#define FTM_OUTMASK_CH4OM(x)   (((uint32_t)(((uint32_t)(x)) << FTM_OUTMASK_CH4OM_SHIFT)) & FTM_OUTMASK_CH4OM_MASK)
 
#define FTM_OUTMASK_CH5OM_MASK   (0x20U)
 
#define FTM_OUTMASK_CH5OM_SHIFT   (5U)
 
#define FTM_OUTMASK_CH5OM(x)   (((uint32_t)(((uint32_t)(x)) << FTM_OUTMASK_CH5OM_SHIFT)) & FTM_OUTMASK_CH5OM_MASK)
 
#define FTM_OUTMASK_CH6OM_MASK   (0x40U)
 
#define FTM_OUTMASK_CH6OM_SHIFT   (6U)
 
#define FTM_OUTMASK_CH6OM(x)   (((uint32_t)(((uint32_t)(x)) << FTM_OUTMASK_CH6OM_SHIFT)) & FTM_OUTMASK_CH6OM_MASK)
 
#define FTM_OUTMASK_CH7OM_MASK   (0x80U)
 
#define FTM_OUTMASK_CH7OM_SHIFT   (7U)
 
#define FTM_OUTMASK_CH7OM(x)   (((uint32_t)(((uint32_t)(x)) << FTM_OUTMASK_CH7OM_SHIFT)) & FTM_OUTMASK_CH7OM_MASK)
 
COMBINE - Function For Linked Channels
#define FTM_COMBINE_COMBINE0_MASK   (0x1U)
 
#define FTM_COMBINE_COMBINE0_SHIFT   (0U)
 
#define FTM_COMBINE_COMBINE0(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_COMBINE0_SHIFT)) & FTM_COMBINE_COMBINE0_MASK)
 
#define FTM_COMBINE_COMP0_MASK   (0x2U)
 
#define FTM_COMBINE_COMP0_SHIFT   (1U)
 
#define FTM_COMBINE_COMP0(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_COMP0_SHIFT)) & FTM_COMBINE_COMP0_MASK)
 
#define FTM_COMBINE_DECAPEN0_MASK   (0x4U)
 
#define FTM_COMBINE_DECAPEN0_SHIFT   (2U)
 
#define FTM_COMBINE_DECAPEN0(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_DECAPEN0_SHIFT)) & FTM_COMBINE_DECAPEN0_MASK)
 
#define FTM_COMBINE_DECAP0_MASK   (0x8U)
 
#define FTM_COMBINE_DECAP0_SHIFT   (3U)
 
#define FTM_COMBINE_DECAP0(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_DECAP0_SHIFT)) & FTM_COMBINE_DECAP0_MASK)
 
#define FTM_COMBINE_DTEN0_MASK   (0x10U)
 
#define FTM_COMBINE_DTEN0_SHIFT   (4U)
 
#define FTM_COMBINE_DTEN0(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_DTEN0_SHIFT)) & FTM_COMBINE_DTEN0_MASK)
 
#define FTM_COMBINE_SYNCEN0_MASK   (0x20U)
 
#define FTM_COMBINE_SYNCEN0_SHIFT   (5U)
 
#define FTM_COMBINE_SYNCEN0(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_SYNCEN0_SHIFT)) & FTM_COMBINE_SYNCEN0_MASK)
 
#define FTM_COMBINE_FAULTEN0_MASK   (0x40U)
 
#define FTM_COMBINE_FAULTEN0_SHIFT   (6U)
 
#define FTM_COMBINE_FAULTEN0(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_FAULTEN0_SHIFT)) & FTM_COMBINE_FAULTEN0_MASK)
 
#define FTM_COMBINE_COMBINE1_MASK   (0x100U)
 
#define FTM_COMBINE_COMBINE1_SHIFT   (8U)
 
#define FTM_COMBINE_COMBINE1(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_COMBINE1_SHIFT)) & FTM_COMBINE_COMBINE1_MASK)
 
#define FTM_COMBINE_COMP1_MASK   (0x200U)
 
#define FTM_COMBINE_COMP1_SHIFT   (9U)
 
#define FTM_COMBINE_COMP1(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_COMP1_SHIFT)) & FTM_COMBINE_COMP1_MASK)
 
#define FTM_COMBINE_DECAPEN1_MASK   (0x400U)
 
#define FTM_COMBINE_DECAPEN1_SHIFT   (10U)
 
#define FTM_COMBINE_DECAPEN1(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_DECAPEN1_SHIFT)) & FTM_COMBINE_DECAPEN1_MASK)
 
#define FTM_COMBINE_DECAP1_MASK   (0x800U)
 
#define FTM_COMBINE_DECAP1_SHIFT   (11U)
 
#define FTM_COMBINE_DECAP1(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_DECAP1_SHIFT)) & FTM_COMBINE_DECAP1_MASK)
 
#define FTM_COMBINE_DTEN1_MASK   (0x1000U)
 
#define FTM_COMBINE_DTEN1_SHIFT   (12U)
 
#define FTM_COMBINE_DTEN1(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_DTEN1_SHIFT)) & FTM_COMBINE_DTEN1_MASK)
 
#define FTM_COMBINE_SYNCEN1_MASK   (0x2000U)
 
#define FTM_COMBINE_SYNCEN1_SHIFT   (13U)
 
#define FTM_COMBINE_SYNCEN1(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_SYNCEN1_SHIFT)) & FTM_COMBINE_SYNCEN1_MASK)
 
#define FTM_COMBINE_FAULTEN1_MASK   (0x4000U)
 
#define FTM_COMBINE_FAULTEN1_SHIFT   (14U)
 
#define FTM_COMBINE_FAULTEN1(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_FAULTEN1_SHIFT)) & FTM_COMBINE_FAULTEN1_MASK)
 
#define FTM_COMBINE_COMBINE2_MASK   (0x10000U)
 
#define FTM_COMBINE_COMBINE2_SHIFT   (16U)
 
#define FTM_COMBINE_COMBINE2(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_COMBINE2_SHIFT)) & FTM_COMBINE_COMBINE2_MASK)
 
#define FTM_COMBINE_COMP2_MASK   (0x20000U)
 
#define FTM_COMBINE_COMP2_SHIFT   (17U)
 
#define FTM_COMBINE_COMP2(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_COMP2_SHIFT)) & FTM_COMBINE_COMP2_MASK)
 
#define FTM_COMBINE_DECAPEN2_MASK   (0x40000U)
 
#define FTM_COMBINE_DECAPEN2_SHIFT   (18U)
 
#define FTM_COMBINE_DECAPEN2(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_DECAPEN2_SHIFT)) & FTM_COMBINE_DECAPEN2_MASK)
 
#define FTM_COMBINE_DECAP2_MASK   (0x80000U)
 
#define FTM_COMBINE_DECAP2_SHIFT   (19U)
 
#define FTM_COMBINE_DECAP2(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_DECAP2_SHIFT)) & FTM_COMBINE_DECAP2_MASK)
 
#define FTM_COMBINE_DTEN2_MASK   (0x100000U)
 
#define FTM_COMBINE_DTEN2_SHIFT   (20U)
 
#define FTM_COMBINE_DTEN2(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_DTEN2_SHIFT)) & FTM_COMBINE_DTEN2_MASK)
 
#define FTM_COMBINE_SYNCEN2_MASK   (0x200000U)
 
#define FTM_COMBINE_SYNCEN2_SHIFT   (21U)
 
#define FTM_COMBINE_SYNCEN2(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_SYNCEN2_SHIFT)) & FTM_COMBINE_SYNCEN2_MASK)
 
#define FTM_COMBINE_FAULTEN2_MASK   (0x400000U)
 
#define FTM_COMBINE_FAULTEN2_SHIFT   (22U)
 
#define FTM_COMBINE_FAULTEN2(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_FAULTEN2_SHIFT)) & FTM_COMBINE_FAULTEN2_MASK)
 
#define FTM_COMBINE_COMBINE3_MASK   (0x1000000U)
 
#define FTM_COMBINE_COMBINE3_SHIFT   (24U)
 
#define FTM_COMBINE_COMBINE3(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_COMBINE3_SHIFT)) & FTM_COMBINE_COMBINE3_MASK)
 
#define FTM_COMBINE_COMP3_MASK   (0x2000000U)
 
#define FTM_COMBINE_COMP3_SHIFT   (25U)
 
#define FTM_COMBINE_COMP3(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_COMP3_SHIFT)) & FTM_COMBINE_COMP3_MASK)
 
#define FTM_COMBINE_DECAPEN3_MASK   (0x4000000U)
 
#define FTM_COMBINE_DECAPEN3_SHIFT   (26U)
 
#define FTM_COMBINE_DECAPEN3(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_DECAPEN3_SHIFT)) & FTM_COMBINE_DECAPEN3_MASK)
 
#define FTM_COMBINE_DECAP3_MASK   (0x8000000U)
 
#define FTM_COMBINE_DECAP3_SHIFT   (27U)
 
#define FTM_COMBINE_DECAP3(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_DECAP3_SHIFT)) & FTM_COMBINE_DECAP3_MASK)
 
#define FTM_COMBINE_DTEN3_MASK   (0x10000000U)
 
#define FTM_COMBINE_DTEN3_SHIFT   (28U)
 
#define FTM_COMBINE_DTEN3(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_DTEN3_SHIFT)) & FTM_COMBINE_DTEN3_MASK)
 
#define FTM_COMBINE_SYNCEN3_MASK   (0x20000000U)
 
#define FTM_COMBINE_SYNCEN3_SHIFT   (29U)
 
#define FTM_COMBINE_SYNCEN3(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_SYNCEN3_SHIFT)) & FTM_COMBINE_SYNCEN3_MASK)
 
#define FTM_COMBINE_FAULTEN3_MASK   (0x40000000U)
 
#define FTM_COMBINE_FAULTEN3_SHIFT   (30U)
 
#define FTM_COMBINE_FAULTEN3(x)   (((uint32_t)(((uint32_t)(x)) << FTM_COMBINE_FAULTEN3_SHIFT)) & FTM_COMBINE_FAULTEN3_MASK)
 
DEADTIME - Deadtime Insertion Control
#define FTM_DEADTIME_DTVAL_MASK   (0x3FU)
 
#define FTM_DEADTIME_DTVAL_SHIFT   (0U)
 
#define FTM_DEADTIME_DTVAL(x)   (((uint32_t)(((uint32_t)(x)) << FTM_DEADTIME_DTVAL_SHIFT)) & FTM_DEADTIME_DTVAL_MASK)
 
#define FTM_DEADTIME_DTPS_MASK   (0xC0U)
 
#define FTM_DEADTIME_DTPS_SHIFT   (6U)
 
#define FTM_DEADTIME_DTPS(x)   (((uint32_t)(((uint32_t)(x)) << FTM_DEADTIME_DTPS_SHIFT)) & FTM_DEADTIME_DTPS_MASK)
 
EXTTRIG - FTM External Trigger
#define FTM_EXTTRIG_CH2TRIG_MASK   (0x1U)
 
#define FTM_EXTTRIG_CH2TRIG_SHIFT   (0U)
 
#define FTM_EXTTRIG_CH2TRIG(x)   (((uint32_t)(((uint32_t)(x)) << FTM_EXTTRIG_CH2TRIG_SHIFT)) & FTM_EXTTRIG_CH2TRIG_MASK)
 
#define FTM_EXTTRIG_CH3TRIG_MASK   (0x2U)
 
#define FTM_EXTTRIG_CH3TRIG_SHIFT   (1U)
 
#define FTM_EXTTRIG_CH3TRIG(x)   (((uint32_t)(((uint32_t)(x)) << FTM_EXTTRIG_CH3TRIG_SHIFT)) & FTM_EXTTRIG_CH3TRIG_MASK)
 
#define FTM_EXTTRIG_CH4TRIG_MASK   (0x4U)
 
#define FTM_EXTTRIG_CH4TRIG_SHIFT   (2U)
 
#define FTM_EXTTRIG_CH4TRIG(x)   (((uint32_t)(((uint32_t)(x)) << FTM_EXTTRIG_CH4TRIG_SHIFT)) & FTM_EXTTRIG_CH4TRIG_MASK)
 
#define FTM_EXTTRIG_CH5TRIG_MASK   (0x8U)
 
#define FTM_EXTTRIG_CH5TRIG_SHIFT   (3U)
 
#define FTM_EXTTRIG_CH5TRIG(x)   (((uint32_t)(((uint32_t)(x)) << FTM_EXTTRIG_CH5TRIG_SHIFT)) & FTM_EXTTRIG_CH5TRIG_MASK)
 
#define FTM_EXTTRIG_CH0TRIG_MASK   (0x10U)
 
#define FTM_EXTTRIG_CH0TRIG_SHIFT   (4U)
 
#define FTM_EXTTRIG_CH0TRIG(x)   (((uint32_t)(((uint32_t)(x)) << FTM_EXTTRIG_CH0TRIG_SHIFT)) & FTM_EXTTRIG_CH0TRIG_MASK)
 
#define FTM_EXTTRIG_CH1TRIG_MASK   (0x20U)
 
#define FTM_EXTTRIG_CH1TRIG_SHIFT   (5U)
 
#define FTM_EXTTRIG_CH1TRIG(x)   (((uint32_t)(((uint32_t)(x)) << FTM_EXTTRIG_CH1TRIG_SHIFT)) & FTM_EXTTRIG_CH1TRIG_MASK)
 
#define FTM_EXTTRIG_INITTRIGEN_MASK   (0x40U)
 
#define FTM_EXTTRIG_INITTRIGEN_SHIFT   (6U)
 
#define FTM_EXTTRIG_INITTRIGEN(x)   (((uint32_t)(((uint32_t)(x)) << FTM_EXTTRIG_INITTRIGEN_SHIFT)) & FTM_EXTTRIG_INITTRIGEN_MASK)
 
#define FTM_EXTTRIG_TRIGF_MASK   (0x80U)
 
#define FTM_EXTTRIG_TRIGF_SHIFT   (7U)
 
#define FTM_EXTTRIG_TRIGF(x)   (((uint32_t)(((uint32_t)(x)) << FTM_EXTTRIG_TRIGF_SHIFT)) & FTM_EXTTRIG_TRIGF_MASK)
 
POL - Channels Polarity
#define FTM_POL_POL0_MASK   (0x1U)
 
#define FTM_POL_POL0_SHIFT   (0U)
 
#define FTM_POL_POL0(x)   (((uint32_t)(((uint32_t)(x)) << FTM_POL_POL0_SHIFT)) & FTM_POL_POL0_MASK)
 
#define FTM_POL_POL1_MASK   (0x2U)
 
#define FTM_POL_POL1_SHIFT   (1U)
 
#define FTM_POL_POL1(x)   (((uint32_t)(((uint32_t)(x)) << FTM_POL_POL1_SHIFT)) & FTM_POL_POL1_MASK)
 
#define FTM_POL_POL2_MASK   (0x4U)
 
#define FTM_POL_POL2_SHIFT   (2U)
 
#define FTM_POL_POL2(x)   (((uint32_t)(((uint32_t)(x)) << FTM_POL_POL2_SHIFT)) & FTM_POL_POL2_MASK)
 
#define FTM_POL_POL3_MASK   (0x8U)
 
#define FTM_POL_POL3_SHIFT   (3U)
 
#define FTM_POL_POL3(x)   (((uint32_t)(((uint32_t)(x)) << FTM_POL_POL3_SHIFT)) & FTM_POL_POL3_MASK)
 
#define FTM_POL_POL4_MASK   (0x10U)
 
#define FTM_POL_POL4_SHIFT   (4U)
 
#define FTM_POL_POL4(x)   (((uint32_t)(((uint32_t)(x)) << FTM_POL_POL4_SHIFT)) & FTM_POL_POL4_MASK)
 
#define FTM_POL_POL5_MASK   (0x20U)
 
#define FTM_POL_POL5_SHIFT   (5U)
 
#define FTM_POL_POL5(x)   (((uint32_t)(((uint32_t)(x)) << FTM_POL_POL5_SHIFT)) & FTM_POL_POL5_MASK)
 
#define FTM_POL_POL6_MASK   (0x40U)
 
#define FTM_POL_POL6_SHIFT   (6U)
 
#define FTM_POL_POL6(x)   (((uint32_t)(((uint32_t)(x)) << FTM_POL_POL6_SHIFT)) & FTM_POL_POL6_MASK)
 
#define FTM_POL_POL7_MASK   (0x80U)
 
#define FTM_POL_POL7_SHIFT   (7U)
 
#define FTM_POL_POL7(x)   (((uint32_t)(((uint32_t)(x)) << FTM_POL_POL7_SHIFT)) & FTM_POL_POL7_MASK)
 
FMS - Fault Mode Status
#define FTM_FMS_FAULTF0_MASK   (0x1U)
 
#define FTM_FMS_FAULTF0_SHIFT   (0U)
 
#define FTM_FMS_FAULTF0(x)   (((uint32_t)(((uint32_t)(x)) << FTM_FMS_FAULTF0_SHIFT)) & FTM_FMS_FAULTF0_MASK)
 
#define FTM_FMS_FAULTF1_MASK   (0x2U)
 
#define FTM_FMS_FAULTF1_SHIFT   (1U)
 
#define FTM_FMS_FAULTF1(x)   (((uint32_t)(((uint32_t)(x)) << FTM_FMS_FAULTF1_SHIFT)) & FTM_FMS_FAULTF1_MASK)
 
#define FTM_FMS_FAULTF2_MASK   (0x4U)
 
#define FTM_FMS_FAULTF2_SHIFT   (2U)
 
#define FTM_FMS_FAULTF2(x)   (((uint32_t)(((uint32_t)(x)) << FTM_FMS_FAULTF2_SHIFT)) & FTM_FMS_FAULTF2_MASK)
 
#define FTM_FMS_FAULTF3_MASK   (0x8U)
 
#define FTM_FMS_FAULTF3_SHIFT   (3U)
 
#define FTM_FMS_FAULTF3(x)   (((uint32_t)(((uint32_t)(x)) << FTM_FMS_FAULTF3_SHIFT)) & FTM_FMS_FAULTF3_MASK)
 
#define FTM_FMS_FAULTIN_MASK   (0x20U)
 
#define FTM_FMS_FAULTIN_SHIFT   (5U)
 
#define FTM_FMS_FAULTIN(x)   (((uint32_t)(((uint32_t)(x)) << FTM_FMS_FAULTIN_SHIFT)) & FTM_FMS_FAULTIN_MASK)
 
#define FTM_FMS_WPEN_MASK   (0x40U)
 
#define FTM_FMS_WPEN_SHIFT   (6U)
 
#define FTM_FMS_WPEN(x)   (((uint32_t)(((uint32_t)(x)) << FTM_FMS_WPEN_SHIFT)) & FTM_FMS_WPEN_MASK)
 
#define FTM_FMS_FAULTF_MASK   (0x80U)
 
#define FTM_FMS_FAULTF_SHIFT   (7U)
 
#define FTM_FMS_FAULTF(x)   (((uint32_t)(((uint32_t)(x)) << FTM_FMS_FAULTF_SHIFT)) & FTM_FMS_FAULTF_MASK)
 
FILTER - Input Capture Filter Control
#define FTM_FILTER_CH0FVAL_MASK   (0xFU)
 
#define FTM_FILTER_CH0FVAL_SHIFT   (0U)
 
#define FTM_FILTER_CH0FVAL(x)   (((uint32_t)(((uint32_t)(x)) << FTM_FILTER_CH0FVAL_SHIFT)) & FTM_FILTER_CH0FVAL_MASK)
 
#define FTM_FILTER_CH1FVAL_MASK   (0xF0U)
 
#define FTM_FILTER_CH1FVAL_SHIFT   (4U)
 
#define FTM_FILTER_CH1FVAL(x)   (((uint32_t)(((uint32_t)(x)) << FTM_FILTER_CH1FVAL_SHIFT)) & FTM_FILTER_CH1FVAL_MASK)
 
#define FTM_FILTER_CH2FVAL_MASK   (0xF00U)
 
#define FTM_FILTER_CH2FVAL_SHIFT   (8U)
 
#define FTM_FILTER_CH2FVAL(x)   (((uint32_t)(((uint32_t)(x)) << FTM_FILTER_CH2FVAL_SHIFT)) & FTM_FILTER_CH2FVAL_MASK)
 
#define FTM_FILTER_CH3FVAL_MASK   (0xF000U)
 
#define FTM_FILTER_CH3FVAL_SHIFT   (12U)
 
#define FTM_FILTER_CH3FVAL(x)   (((uint32_t)(((uint32_t)(x)) << FTM_FILTER_CH3FVAL_SHIFT)) & FTM_FILTER_CH3FVAL_MASK)
 
FLTCTRL - Fault Control
#define FTM_FLTCTRL_FAULT0EN_MASK   (0x1U)
 
#define FTM_FLTCTRL_FAULT0EN_SHIFT   (0U)
 
#define FTM_FLTCTRL_FAULT0EN(x)   (((uint32_t)(((uint32_t)(x)) << FTM_FLTCTRL_FAULT0EN_SHIFT)) & FTM_FLTCTRL_FAULT0EN_MASK)
 
#define FTM_FLTCTRL_FAULT1EN_MASK   (0x2U)
 
#define FTM_FLTCTRL_FAULT1EN_SHIFT   (1U)
 
#define FTM_FLTCTRL_FAULT1EN(x)   (((uint32_t)(((uint32_t)(x)) << FTM_FLTCTRL_FAULT1EN_SHIFT)) & FTM_FLTCTRL_FAULT1EN_MASK)
 
#define FTM_FLTCTRL_FAULT2EN_MASK   (0x4U)
 
#define FTM_FLTCTRL_FAULT2EN_SHIFT   (2U)
 
#define FTM_FLTCTRL_FAULT2EN(x)   (((uint32_t)(((uint32_t)(x)) << FTM_FLTCTRL_FAULT2EN_SHIFT)) & FTM_FLTCTRL_FAULT2EN_MASK)
 
#define FTM_FLTCTRL_FAULT3EN_MASK   (0x8U)
 
#define FTM_FLTCTRL_FAULT3EN_SHIFT   (3U)
 
#define FTM_FLTCTRL_FAULT3EN(x)   (((uint32_t)(((uint32_t)(x)) << FTM_FLTCTRL_FAULT3EN_SHIFT)) & FTM_FLTCTRL_FAULT3EN_MASK)
 
#define FTM_FLTCTRL_FFLTR0EN_MASK   (0x10U)
 
#define FTM_FLTCTRL_FFLTR0EN_SHIFT   (4U)
 
#define FTM_FLTCTRL_FFLTR0EN(x)   (((uint32_t)(((uint32_t)(x)) << FTM_FLTCTRL_FFLTR0EN_SHIFT)) & FTM_FLTCTRL_FFLTR0EN_MASK)
 
#define FTM_FLTCTRL_FFLTR1EN_MASK   (0x20U)
 
#define FTM_FLTCTRL_FFLTR1EN_SHIFT   (5U)
 
#define FTM_FLTCTRL_FFLTR1EN(x)   (((uint32_t)(((uint32_t)(x)) << FTM_FLTCTRL_FFLTR1EN_SHIFT)) & FTM_FLTCTRL_FFLTR1EN_MASK)
 
#define FTM_FLTCTRL_FFLTR2EN_MASK   (0x40U)
 
#define FTM_FLTCTRL_FFLTR2EN_SHIFT   (6U)
 
#define FTM_FLTCTRL_FFLTR2EN(x)   (((uint32_t)(((uint32_t)(x)) << FTM_FLTCTRL_FFLTR2EN_SHIFT)) & FTM_FLTCTRL_FFLTR2EN_MASK)
 
#define FTM_FLTCTRL_FFLTR3EN_MASK   (0x80U)
 
#define FTM_FLTCTRL_FFLTR3EN_SHIFT   (7U)
 
#define FTM_FLTCTRL_FFLTR3EN(x)   (((uint32_t)(((uint32_t)(x)) << FTM_FLTCTRL_FFLTR3EN_SHIFT)) & FTM_FLTCTRL_FFLTR3EN_MASK)
 
#define FTM_FLTCTRL_FFVAL_MASK   (0xF00U)
 
#define FTM_FLTCTRL_FFVAL_SHIFT   (8U)
 
#define FTM_FLTCTRL_FFVAL(x)   (((uint32_t)(((uint32_t)(x)) << FTM_FLTCTRL_FFVAL_SHIFT)) & FTM_FLTCTRL_FFVAL_MASK)
 
QDCTRL - Quadrature Decoder Control And Status
#define FTM_QDCTRL_QUADEN_MASK   (0x1U)
 
#define FTM_QDCTRL_QUADEN_SHIFT   (0U)
 
#define FTM_QDCTRL_QUADEN(x)   (((uint32_t)(((uint32_t)(x)) << FTM_QDCTRL_QUADEN_SHIFT)) & FTM_QDCTRL_QUADEN_MASK)
 
#define FTM_QDCTRL_TOFDIR_MASK   (0x2U)
 
#define FTM_QDCTRL_TOFDIR_SHIFT   (1U)
 
#define FTM_QDCTRL_TOFDIR(x)   (((uint32_t)(((uint32_t)(x)) << FTM_QDCTRL_TOFDIR_SHIFT)) & FTM_QDCTRL_TOFDIR_MASK)
 
#define FTM_QDCTRL_QUADIR_MASK   (0x4U)
 
#define FTM_QDCTRL_QUADIR_SHIFT   (2U)
 
#define FTM_QDCTRL_QUADIR(x)   (((uint32_t)(((uint32_t)(x)) << FTM_QDCTRL_QUADIR_SHIFT)) & FTM_QDCTRL_QUADIR_MASK)
 
#define FTM_QDCTRL_QUADMODE_MASK   (0x8U)
 
#define FTM_QDCTRL_QUADMODE_SHIFT   (3U)
 
#define FTM_QDCTRL_QUADMODE(x)   (((uint32_t)(((uint32_t)(x)) << FTM_QDCTRL_QUADMODE_SHIFT)) & FTM_QDCTRL_QUADMODE_MASK)
 
#define FTM_QDCTRL_PHBPOL_MASK   (0x10U)
 
#define FTM_QDCTRL_PHBPOL_SHIFT   (4U)
 
#define FTM_QDCTRL_PHBPOL(x)   (((uint32_t)(((uint32_t)(x)) << FTM_QDCTRL_PHBPOL_SHIFT)) & FTM_QDCTRL_PHBPOL_MASK)
 
#define FTM_QDCTRL_PHAPOL_MASK   (0x20U)
 
#define FTM_QDCTRL_PHAPOL_SHIFT   (5U)
 
#define FTM_QDCTRL_PHAPOL(x)   (((uint32_t)(((uint32_t)(x)) << FTM_QDCTRL_PHAPOL_SHIFT)) & FTM_QDCTRL_PHAPOL_MASK)
 
#define FTM_QDCTRL_PHBFLTREN_MASK   (0x40U)
 
#define FTM_QDCTRL_PHBFLTREN_SHIFT   (6U)
 
#define FTM_QDCTRL_PHBFLTREN(x)   (((uint32_t)(((uint32_t)(x)) << FTM_QDCTRL_PHBFLTREN_SHIFT)) & FTM_QDCTRL_PHBFLTREN_MASK)
 
#define FTM_QDCTRL_PHAFLTREN_MASK   (0x80U)
 
#define FTM_QDCTRL_PHAFLTREN_SHIFT   (7U)
 
#define FTM_QDCTRL_PHAFLTREN(x)   (((uint32_t)(((uint32_t)(x)) << FTM_QDCTRL_PHAFLTREN_SHIFT)) & FTM_QDCTRL_PHAFLTREN_MASK)
 
CONF - Configuration
#define FTM_CONF_NUMTOF_MASK   (0x1FU)
 
#define FTM_CONF_NUMTOF_SHIFT   (0U)
 
#define FTM_CONF_NUMTOF(x)   (((uint32_t)(((uint32_t)(x)) << FTM_CONF_NUMTOF_SHIFT)) & FTM_CONF_NUMTOF_MASK)
 
#define FTM_CONF_BDMMODE_MASK   (0xC0U)
 
#define FTM_CONF_BDMMODE_SHIFT   (6U)
 
#define FTM_CONF_BDMMODE(x)   (((uint32_t)(((uint32_t)(x)) << FTM_CONF_BDMMODE_SHIFT)) & FTM_CONF_BDMMODE_MASK)
 
#define FTM_CONF_GTBEEN_MASK   (0x200U)
 
#define FTM_CONF_GTBEEN_SHIFT   (9U)
 
#define FTM_CONF_GTBEEN(x)   (((uint32_t)(((uint32_t)(x)) << FTM_CONF_GTBEEN_SHIFT)) & FTM_CONF_GTBEEN_MASK)
 
#define FTM_CONF_GTBEOUT_MASK   (0x400U)
 
#define FTM_CONF_GTBEOUT_SHIFT   (10U)
 
#define FTM_CONF_GTBEOUT(x)   (((uint32_t)(((uint32_t)(x)) << FTM_CONF_GTBEOUT_SHIFT)) & FTM_CONF_GTBEOUT_MASK)
 
FLTPOL - FTM Fault Input Polarity
#define FTM_FLTPOL_FLT0POL_MASK   (0x1U)
 
#define FTM_FLTPOL_FLT0POL_SHIFT   (0U)
 
#define FTM_FLTPOL_FLT0POL(x)   (((uint32_t)(((uint32_t)(x)) << FTM_FLTPOL_FLT0POL_SHIFT)) & FTM_FLTPOL_FLT0POL_MASK)
 
#define FTM_FLTPOL_FLT1POL_MASK   (0x2U)
 
#define FTM_FLTPOL_FLT1POL_SHIFT   (1U)
 
#define FTM_FLTPOL_FLT1POL(x)   (((uint32_t)(((uint32_t)(x)) << FTM_FLTPOL_FLT1POL_SHIFT)) & FTM_FLTPOL_FLT1POL_MASK)
 
#define FTM_FLTPOL_FLT2POL_MASK   (0x4U)
 
#define FTM_FLTPOL_FLT2POL_SHIFT   (2U)
 
#define FTM_FLTPOL_FLT2POL(x)   (((uint32_t)(((uint32_t)(x)) << FTM_FLTPOL_FLT2POL_SHIFT)) & FTM_FLTPOL_FLT2POL_MASK)
 
#define FTM_FLTPOL_FLT3POL_MASK   (0x8U)
 
#define FTM_FLTPOL_FLT3POL_SHIFT   (3U)
 
#define FTM_FLTPOL_FLT3POL(x)   (((uint32_t)(((uint32_t)(x)) << FTM_FLTPOL_FLT3POL_SHIFT)) & FTM_FLTPOL_FLT3POL_MASK)
 
SYNCONF - Synchronization Configuration
#define FTM_SYNCONF_HWTRIGMODE_MASK   (0x1U)
 
#define FTM_SYNCONF_HWTRIGMODE_SHIFT   (0U)
 
#define FTM_SYNCONF_HWTRIGMODE(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SYNCONF_HWTRIGMODE_SHIFT)) & FTM_SYNCONF_HWTRIGMODE_MASK)
 
#define FTM_SYNCONF_CNTINC_MASK   (0x4U)
 
#define FTM_SYNCONF_CNTINC_SHIFT   (2U)
 
#define FTM_SYNCONF_CNTINC(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SYNCONF_CNTINC_SHIFT)) & FTM_SYNCONF_CNTINC_MASK)
 
#define FTM_SYNCONF_INVC_MASK   (0x10U)
 
#define FTM_SYNCONF_INVC_SHIFT   (4U)
 
#define FTM_SYNCONF_INVC(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SYNCONF_INVC_SHIFT)) & FTM_SYNCONF_INVC_MASK)
 
#define FTM_SYNCONF_SWOC_MASK   (0x20U)
 
#define FTM_SYNCONF_SWOC_SHIFT   (5U)
 
#define FTM_SYNCONF_SWOC(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SYNCONF_SWOC_SHIFT)) & FTM_SYNCONF_SWOC_MASK)
 
#define FTM_SYNCONF_SYNCMODE_MASK   (0x80U)
 
#define FTM_SYNCONF_SYNCMODE_SHIFT   (7U)
 
#define FTM_SYNCONF_SYNCMODE(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SYNCONF_SYNCMODE_SHIFT)) & FTM_SYNCONF_SYNCMODE_MASK)
 
#define FTM_SYNCONF_SWRSTCNT_MASK   (0x100U)
 
#define FTM_SYNCONF_SWRSTCNT_SHIFT   (8U)
 
#define FTM_SYNCONF_SWRSTCNT(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SYNCONF_SWRSTCNT_SHIFT)) & FTM_SYNCONF_SWRSTCNT_MASK)
 
#define FTM_SYNCONF_SWWRBUF_MASK   (0x200U)
 
#define FTM_SYNCONF_SWWRBUF_SHIFT   (9U)
 
#define FTM_SYNCONF_SWWRBUF(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SYNCONF_SWWRBUF_SHIFT)) & FTM_SYNCONF_SWWRBUF_MASK)
 
#define FTM_SYNCONF_SWOM_MASK   (0x400U)
 
#define FTM_SYNCONF_SWOM_SHIFT   (10U)
 
#define FTM_SYNCONF_SWOM(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SYNCONF_SWOM_SHIFT)) & FTM_SYNCONF_SWOM_MASK)
 
#define FTM_SYNCONF_SWINVC_MASK   (0x800U)
 
#define FTM_SYNCONF_SWINVC_SHIFT   (11U)
 
#define FTM_SYNCONF_SWINVC(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SYNCONF_SWINVC_SHIFT)) & FTM_SYNCONF_SWINVC_MASK)
 
#define FTM_SYNCONF_SWSOC_MASK   (0x1000U)
 
#define FTM_SYNCONF_SWSOC_SHIFT   (12U)
 
#define FTM_SYNCONF_SWSOC(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SYNCONF_SWSOC_SHIFT)) & FTM_SYNCONF_SWSOC_MASK)
 
#define FTM_SYNCONF_HWRSTCNT_MASK   (0x10000U)
 
#define FTM_SYNCONF_HWRSTCNT_SHIFT   (16U)
 
#define FTM_SYNCONF_HWRSTCNT(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SYNCONF_HWRSTCNT_SHIFT)) & FTM_SYNCONF_HWRSTCNT_MASK)
 
#define FTM_SYNCONF_HWWRBUF_MASK   (0x20000U)
 
#define FTM_SYNCONF_HWWRBUF_SHIFT   (17U)
 
#define FTM_SYNCONF_HWWRBUF(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SYNCONF_HWWRBUF_SHIFT)) & FTM_SYNCONF_HWWRBUF_MASK)
 
#define FTM_SYNCONF_HWOM_MASK   (0x40000U)
 
#define FTM_SYNCONF_HWOM_SHIFT   (18U)
 
#define FTM_SYNCONF_HWOM(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SYNCONF_HWOM_SHIFT)) & FTM_SYNCONF_HWOM_MASK)
 
#define FTM_SYNCONF_HWINVC_MASK   (0x80000U)
 
#define FTM_SYNCONF_HWINVC_SHIFT   (19U)
 
#define FTM_SYNCONF_HWINVC(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SYNCONF_HWINVC_SHIFT)) & FTM_SYNCONF_HWINVC_MASK)
 
#define FTM_SYNCONF_HWSOC_MASK   (0x100000U)
 
#define FTM_SYNCONF_HWSOC_SHIFT   (20U)
 
#define FTM_SYNCONF_HWSOC(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SYNCONF_HWSOC_SHIFT)) & FTM_SYNCONF_HWSOC_MASK)
 
INVCTRL - FTM Inverting Control
#define FTM_INVCTRL_INV0EN_MASK   (0x1U)
 
#define FTM_INVCTRL_INV0EN_SHIFT   (0U)
 
#define FTM_INVCTRL_INV0EN(x)   (((uint32_t)(((uint32_t)(x)) << FTM_INVCTRL_INV0EN_SHIFT)) & FTM_INVCTRL_INV0EN_MASK)
 
#define FTM_INVCTRL_INV1EN_MASK   (0x2U)
 
#define FTM_INVCTRL_INV1EN_SHIFT   (1U)
 
#define FTM_INVCTRL_INV1EN(x)   (((uint32_t)(((uint32_t)(x)) << FTM_INVCTRL_INV1EN_SHIFT)) & FTM_INVCTRL_INV1EN_MASK)
 
#define FTM_INVCTRL_INV2EN_MASK   (0x4U)
 
#define FTM_INVCTRL_INV2EN_SHIFT   (2U)
 
#define FTM_INVCTRL_INV2EN(x)   (((uint32_t)(((uint32_t)(x)) << FTM_INVCTRL_INV2EN_SHIFT)) & FTM_INVCTRL_INV2EN_MASK)
 
#define FTM_INVCTRL_INV3EN_MASK   (0x8U)
 
#define FTM_INVCTRL_INV3EN_SHIFT   (3U)
 
#define FTM_INVCTRL_INV3EN(x)   (((uint32_t)(((uint32_t)(x)) << FTM_INVCTRL_INV3EN_SHIFT)) & FTM_INVCTRL_INV3EN_MASK)
 
SWOCTRL - FTM Software Output Control
#define FTM_SWOCTRL_CH0OC_MASK   (0x1U)
 
#define FTM_SWOCTRL_CH0OC_SHIFT   (0U)
 
#define FTM_SWOCTRL_CH0OC(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SWOCTRL_CH0OC_SHIFT)) & FTM_SWOCTRL_CH0OC_MASK)
 
#define FTM_SWOCTRL_CH1OC_MASK   (0x2U)
 
#define FTM_SWOCTRL_CH1OC_SHIFT   (1U)
 
#define FTM_SWOCTRL_CH1OC(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SWOCTRL_CH1OC_SHIFT)) & FTM_SWOCTRL_CH1OC_MASK)
 
#define FTM_SWOCTRL_CH2OC_MASK   (0x4U)
 
#define FTM_SWOCTRL_CH2OC_SHIFT   (2U)
 
#define FTM_SWOCTRL_CH2OC(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SWOCTRL_CH2OC_SHIFT)) & FTM_SWOCTRL_CH2OC_MASK)
 
#define FTM_SWOCTRL_CH3OC_MASK   (0x8U)
 
#define FTM_SWOCTRL_CH3OC_SHIFT   (3U)
 
#define FTM_SWOCTRL_CH3OC(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SWOCTRL_CH3OC_SHIFT)) & FTM_SWOCTRL_CH3OC_MASK)
 
#define FTM_SWOCTRL_CH4OC_MASK   (0x10U)
 
#define FTM_SWOCTRL_CH4OC_SHIFT   (4U)
 
#define FTM_SWOCTRL_CH4OC(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SWOCTRL_CH4OC_SHIFT)) & FTM_SWOCTRL_CH4OC_MASK)
 
#define FTM_SWOCTRL_CH5OC_MASK   (0x20U)
 
#define FTM_SWOCTRL_CH5OC_SHIFT   (5U)
 
#define FTM_SWOCTRL_CH5OC(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SWOCTRL_CH5OC_SHIFT)) & FTM_SWOCTRL_CH5OC_MASK)
 
#define FTM_SWOCTRL_CH6OC_MASK   (0x40U)
 
#define FTM_SWOCTRL_CH6OC_SHIFT   (6U)
 
#define FTM_SWOCTRL_CH6OC(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SWOCTRL_CH6OC_SHIFT)) & FTM_SWOCTRL_CH6OC_MASK)
 
#define FTM_SWOCTRL_CH7OC_MASK   (0x80U)
 
#define FTM_SWOCTRL_CH7OC_SHIFT   (7U)
 
#define FTM_SWOCTRL_CH7OC(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SWOCTRL_CH7OC_SHIFT)) & FTM_SWOCTRL_CH7OC_MASK)
 
#define FTM_SWOCTRL_CH0OCV_MASK   (0x100U)
 
#define FTM_SWOCTRL_CH0OCV_SHIFT   (8U)
 
#define FTM_SWOCTRL_CH0OCV(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SWOCTRL_CH0OCV_SHIFT)) & FTM_SWOCTRL_CH0OCV_MASK)
 
#define FTM_SWOCTRL_CH1OCV_MASK   (0x200U)
 
#define FTM_SWOCTRL_CH1OCV_SHIFT   (9U)
 
#define FTM_SWOCTRL_CH1OCV(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SWOCTRL_CH1OCV_SHIFT)) & FTM_SWOCTRL_CH1OCV_MASK)
 
#define FTM_SWOCTRL_CH2OCV_MASK   (0x400U)
 
#define FTM_SWOCTRL_CH2OCV_SHIFT   (10U)
 
#define FTM_SWOCTRL_CH2OCV(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SWOCTRL_CH2OCV_SHIFT)) & FTM_SWOCTRL_CH2OCV_MASK)
 
#define FTM_SWOCTRL_CH3OCV_MASK   (0x800U)
 
#define FTM_SWOCTRL_CH3OCV_SHIFT   (11U)
 
#define FTM_SWOCTRL_CH3OCV(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SWOCTRL_CH3OCV_SHIFT)) & FTM_SWOCTRL_CH3OCV_MASK)
 
#define FTM_SWOCTRL_CH4OCV_MASK   (0x1000U)
 
#define FTM_SWOCTRL_CH4OCV_SHIFT   (12U)
 
#define FTM_SWOCTRL_CH4OCV(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SWOCTRL_CH4OCV_SHIFT)) & FTM_SWOCTRL_CH4OCV_MASK)
 
#define FTM_SWOCTRL_CH5OCV_MASK   (0x2000U)
 
#define FTM_SWOCTRL_CH5OCV_SHIFT   (13U)
 
#define FTM_SWOCTRL_CH5OCV(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SWOCTRL_CH5OCV_SHIFT)) & FTM_SWOCTRL_CH5OCV_MASK)
 
#define FTM_SWOCTRL_CH6OCV_MASK   (0x4000U)
 
#define FTM_SWOCTRL_CH6OCV_SHIFT   (14U)
 
#define FTM_SWOCTRL_CH6OCV(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SWOCTRL_CH6OCV_SHIFT)) & FTM_SWOCTRL_CH6OCV_MASK)
 
#define FTM_SWOCTRL_CH7OCV_MASK   (0x8000U)
 
#define FTM_SWOCTRL_CH7OCV_SHIFT   (15U)
 
#define FTM_SWOCTRL_CH7OCV(x)   (((uint32_t)(((uint32_t)(x)) << FTM_SWOCTRL_CH7OCV_SHIFT)) & FTM_SWOCTRL_CH7OCV_MASK)
 
PWMLOAD - FTM PWM Load
#define FTM_PWMLOAD_CH0SEL_MASK   (0x1U)
 
#define FTM_PWMLOAD_CH0SEL_SHIFT   (0U)
 
#define FTM_PWMLOAD_CH0SEL(x)   (((uint32_t)(((uint32_t)(x)) << FTM_PWMLOAD_CH0SEL_SHIFT)) & FTM_PWMLOAD_CH0SEL_MASK)
 
#define FTM_PWMLOAD_CH1SEL_MASK   (0x2U)
 
#define FTM_PWMLOAD_CH1SEL_SHIFT   (1U)
 
#define FTM_PWMLOAD_CH1SEL(x)   (((uint32_t)(((uint32_t)(x)) << FTM_PWMLOAD_CH1SEL_SHIFT)) & FTM_PWMLOAD_CH1SEL_MASK)
 
#define FTM_PWMLOAD_CH2SEL_MASK   (0x4U)
 
#define FTM_PWMLOAD_CH2SEL_SHIFT   (2U)
 
#define FTM_PWMLOAD_CH2SEL(x)   (((uint32_t)(((uint32_t)(x)) << FTM_PWMLOAD_CH2SEL_SHIFT)) & FTM_PWMLOAD_CH2SEL_MASK)
 
#define FTM_PWMLOAD_CH3SEL_MASK   (0x8U)
 
#define FTM_PWMLOAD_CH3SEL_SHIFT   (3U)
 
#define FTM_PWMLOAD_CH3SEL(x)   (((uint32_t)(((uint32_t)(x)) << FTM_PWMLOAD_CH3SEL_SHIFT)) & FTM_PWMLOAD_CH3SEL_MASK)
 
#define FTM_PWMLOAD_CH4SEL_MASK   (0x10U)
 
#define FTM_PWMLOAD_CH4SEL_SHIFT   (4U)
 
#define FTM_PWMLOAD_CH4SEL(x)   (((uint32_t)(((uint32_t)(x)) << FTM_PWMLOAD_CH4SEL_SHIFT)) & FTM_PWMLOAD_CH4SEL_MASK)
 
#define FTM_PWMLOAD_CH5SEL_MASK   (0x20U)
 
#define FTM_PWMLOAD_CH5SEL_SHIFT   (5U)
 
#define FTM_PWMLOAD_CH5SEL(x)   (((uint32_t)(((uint32_t)(x)) << FTM_PWMLOAD_CH5SEL_SHIFT)) & FTM_PWMLOAD_CH5SEL_MASK)
 
#define FTM_PWMLOAD_CH6SEL_MASK   (0x40U)
 
#define FTM_PWMLOAD_CH6SEL_SHIFT   (6U)
 
#define FTM_PWMLOAD_CH6SEL(x)   (((uint32_t)(((uint32_t)(x)) << FTM_PWMLOAD_CH6SEL_SHIFT)) & FTM_PWMLOAD_CH6SEL_MASK)
 
#define FTM_PWMLOAD_CH7SEL_MASK   (0x80U)
 
#define FTM_PWMLOAD_CH7SEL_SHIFT   (7U)
 
#define FTM_PWMLOAD_CH7SEL(x)   (((uint32_t)(((uint32_t)(x)) << FTM_PWMLOAD_CH7SEL_SHIFT)) & FTM_PWMLOAD_CH7SEL_MASK)
 
#define FTM_PWMLOAD_LDOK_MASK   (0x200U)
 
#define FTM_PWMLOAD_LDOK_SHIFT   (9U)
 
#define FTM_PWMLOAD_LDOK(x)   (((uint32_t)(((uint32_t)(x)) << FTM_PWMLOAD_LDOK_SHIFT)) & FTM_PWMLOAD_LDOK_MASK)
 
PDOR - Port Data Output Register
#define GPIO_PDOR_PDO_MASK   (0xFFFFFFFFU)
 
#define GPIO_PDOR_PDO_SHIFT   (0U)
 
#define GPIO_PDOR_PDO(x)   (((uint32_t)(((uint32_t)(x)) << GPIO_PDOR_PDO_SHIFT)) & GPIO_PDOR_PDO_MASK)
 
PSOR - Port Set Output Register
#define GPIO_PSOR_PTSO_MASK   (0xFFFFFFFFU)
 
#define GPIO_PSOR_PTSO_SHIFT   (0U)
 
#define GPIO_PSOR_PTSO(x)   (((uint32_t)(((uint32_t)(x)) << GPIO_PSOR_PTSO_SHIFT)) & GPIO_PSOR_PTSO_MASK)
 
PCOR - Port Clear Output Register
#define GPIO_PCOR_PTCO_MASK   (0xFFFFFFFFU)
 
#define GPIO_PCOR_PTCO_SHIFT   (0U)
 
#define GPIO_PCOR_PTCO(x)   (((uint32_t)(((uint32_t)(x)) << GPIO_PCOR_PTCO_SHIFT)) & GPIO_PCOR_PTCO_MASK)
 
PTOR - Port Toggle Output Register
#define GPIO_PTOR_PTTO_MASK   (0xFFFFFFFFU)
 
#define GPIO_PTOR_PTTO_SHIFT   (0U)
 
#define GPIO_PTOR_PTTO(x)   (((uint32_t)(((uint32_t)(x)) << GPIO_PTOR_PTTO_SHIFT)) & GPIO_PTOR_PTTO_MASK)
 
PDIR - Port Data Input Register
#define GPIO_PDIR_PDI_MASK   (0xFFFFFFFFU)
 
#define GPIO_PDIR_PDI_SHIFT   (0U)
 
#define GPIO_PDIR_PDI(x)   (((uint32_t)(((uint32_t)(x)) << GPIO_PDIR_PDI_SHIFT)) & GPIO_PDIR_PDI_MASK)
 
PDDR - Port Data Direction Register
#define GPIO_PDDR_PDD_MASK   (0xFFFFFFFFU)
 
#define GPIO_PDDR_PDD_SHIFT   (0U)
 
#define GPIO_PDDR_PDD(x)   (((uint32_t)(((uint32_t)(x)) << GPIO_PDDR_PDD_SHIFT)) & GPIO_PDDR_PDD_MASK)
 
A1 - I2C Address Register 1
#define I2C_A1_AD_MASK   (0xFEU)
 
#define I2C_A1_AD_SHIFT   (1U)
 
#define I2C_A1_AD(x)   (((uint8_t)(((uint8_t)(x)) << I2C_A1_AD_SHIFT)) & I2C_A1_AD_MASK)
 
F - I2C Frequency Divider register
#define I2C_F_ICR_MASK   (0x3FU)
 
#define I2C_F_ICR_SHIFT   (0U)
 
#define I2C_F_ICR(x)   (((uint8_t)(((uint8_t)(x)) << I2C_F_ICR_SHIFT)) & I2C_F_ICR_MASK)
 
#define I2C_F_MULT_MASK   (0xC0U)
 
#define I2C_F_MULT_SHIFT   (6U)
 
#define I2C_F_MULT(x)   (((uint8_t)(((uint8_t)(x)) << I2C_F_MULT_SHIFT)) & I2C_F_MULT_MASK)
 
C1 - I2C Control Register 1
#define I2C_C1_DMAEN_MASK   (0x1U)
 
#define I2C_C1_DMAEN_SHIFT   (0U)
 
#define I2C_C1_DMAEN(x)   (((uint8_t)(((uint8_t)(x)) << I2C_C1_DMAEN_SHIFT)) & I2C_C1_DMAEN_MASK)
 
#define I2C_C1_WUEN_MASK   (0x2U)
 
#define I2C_C1_WUEN_SHIFT   (1U)
 
#define I2C_C1_WUEN(x)   (((uint8_t)(((uint8_t)(x)) << I2C_C1_WUEN_SHIFT)) & I2C_C1_WUEN_MASK)
 
#define I2C_C1_RSTA_MASK   (0x4U)
 
#define I2C_C1_RSTA_SHIFT   (2U)
 
#define I2C_C1_RSTA(x)   (((uint8_t)(((uint8_t)(x)) << I2C_C1_RSTA_SHIFT)) & I2C_C1_RSTA_MASK)
 
#define I2C_C1_TXAK_MASK   (0x8U)
 
#define I2C_C1_TXAK_SHIFT   (3U)
 
#define I2C_C1_TXAK(x)   (((uint8_t)(((uint8_t)(x)) << I2C_C1_TXAK_SHIFT)) & I2C_C1_TXAK_MASK)
 
#define I2C_C1_TX_MASK   (0x10U)
 
#define I2C_C1_TX_SHIFT   (4U)
 
#define I2C_C1_TX(x)   (((uint8_t)(((uint8_t)(x)) << I2C_C1_TX_SHIFT)) & I2C_C1_TX_MASK)
 
#define I2C_C1_MST_MASK   (0x20U)
 
#define I2C_C1_MST_SHIFT   (5U)
 
#define I2C_C1_MST(x)   (((uint8_t)(((uint8_t)(x)) << I2C_C1_MST_SHIFT)) & I2C_C1_MST_MASK)
 
#define I2C_C1_IICIE_MASK   (0x40U)
 
#define I2C_C1_IICIE_SHIFT   (6U)
 
#define I2C_C1_IICIE(x)   (((uint8_t)(((uint8_t)(x)) << I2C_C1_IICIE_SHIFT)) & I2C_C1_IICIE_MASK)
 
#define I2C_C1_IICEN_MASK   (0x80U)
 
#define I2C_C1_IICEN_SHIFT   (7U)
 
#define I2C_C1_IICEN(x)   (((uint8_t)(((uint8_t)(x)) << I2C_C1_IICEN_SHIFT)) & I2C_C1_IICEN_MASK)
 
S - I2C Status register
#define I2C_S_RXAK_MASK   (0x1U)
 
#define I2C_S_RXAK_SHIFT   (0U)
 
#define I2C_S_RXAK(x)   (((uint8_t)(((uint8_t)(x)) << I2C_S_RXAK_SHIFT)) & I2C_S_RXAK_MASK)
 
#define I2C_S_IICIF_MASK   (0x2U)
 
#define I2C_S_IICIF_SHIFT   (1U)
 
#define I2C_S_IICIF(x)   (((uint8_t)(((uint8_t)(x)) << I2C_S_IICIF_SHIFT)) & I2C_S_IICIF_MASK)
 
#define I2C_S_SRW_MASK   (0x4U)
 
#define I2C_S_SRW_SHIFT   (2U)
 
#define I2C_S_SRW(x)   (((uint8_t)(((uint8_t)(x)) << I2C_S_SRW_SHIFT)) & I2C_S_SRW_MASK)
 
#define I2C_S_RAM_MASK   (0x8U)
 
#define I2C_S_RAM_SHIFT   (3U)
 
#define I2C_S_RAM(x)   (((uint8_t)(((uint8_t)(x)) << I2C_S_RAM_SHIFT)) & I2C_S_RAM_MASK)
 
#define I2C_S_ARBL_MASK   (0x10U)
 
#define I2C_S_ARBL_SHIFT   (4U)
 
#define I2C_S_ARBL(x)   (((uint8_t)(((uint8_t)(x)) << I2C_S_ARBL_SHIFT)) & I2C_S_ARBL_MASK)
 
#define I2C_S_BUSY_MASK   (0x20U)
 
#define I2C_S_BUSY_SHIFT   (5U)
 
#define I2C_S_BUSY(x)   (((uint8_t)(((uint8_t)(x)) << I2C_S_BUSY_SHIFT)) & I2C_S_BUSY_MASK)
 
#define I2C_S_IAAS_MASK   (0x40U)
 
#define I2C_S_IAAS_SHIFT   (6U)
 
#define I2C_S_IAAS(x)   (((uint8_t)(((uint8_t)(x)) << I2C_S_IAAS_SHIFT)) & I2C_S_IAAS_MASK)
 
#define I2C_S_TCF_MASK   (0x80U)
 
#define I2C_S_TCF_SHIFT   (7U)
 
#define I2C_S_TCF(x)   (((uint8_t)(((uint8_t)(x)) << I2C_S_TCF_SHIFT)) & I2C_S_TCF_MASK)
 
D - I2C Data I/O register
#define I2C_D_DATA_MASK   (0xFFU)
 
#define I2C_D_DATA_SHIFT   (0U)
 
#define I2C_D_DATA(x)   (((uint8_t)(((uint8_t)(x)) << I2C_D_DATA_SHIFT)) & I2C_D_DATA_MASK)
 
C2 - I2C Control Register 2
#define I2C_C2_AD_MASK   (0x7U)
 
#define I2C_C2_AD_SHIFT   (0U)
 
#define I2C_C2_AD(x)   (((uint8_t)(((uint8_t)(x)) << I2C_C2_AD_SHIFT)) & I2C_C2_AD_MASK)
 
#define I2C_C2_RMEN_MASK   (0x8U)
 
#define I2C_C2_RMEN_SHIFT   (3U)
 
#define I2C_C2_RMEN(x)   (((uint8_t)(((uint8_t)(x)) << I2C_C2_RMEN_SHIFT)) & I2C_C2_RMEN_MASK)
 
#define I2C_C2_SBRC_MASK   (0x10U)
 
#define I2C_C2_SBRC_SHIFT   (4U)
 
#define I2C_C2_SBRC(x)   (((uint8_t)(((uint8_t)(x)) << I2C_C2_SBRC_SHIFT)) & I2C_C2_SBRC_MASK)
 
#define I2C_C2_HDRS_MASK   (0x20U)
 
#define I2C_C2_HDRS_SHIFT   (5U)
 
#define I2C_C2_HDRS(x)   (((uint8_t)(((uint8_t)(x)) << I2C_C2_HDRS_SHIFT)) & I2C_C2_HDRS_MASK)
 
#define I2C_C2_ADEXT_MASK   (0x40U)
 
#define I2C_C2_ADEXT_SHIFT   (6U)
 
#define I2C_C2_ADEXT(x)   (((uint8_t)(((uint8_t)(x)) << I2C_C2_ADEXT_SHIFT)) & I2C_C2_ADEXT_MASK)
 
#define I2C_C2_GCAEN_MASK   (0x80U)
 
#define I2C_C2_GCAEN_SHIFT   (7U)
 
#define I2C_C2_GCAEN(x)   (((uint8_t)(((uint8_t)(x)) << I2C_C2_GCAEN_SHIFT)) & I2C_C2_GCAEN_MASK)
 
FLT - I2C Programmable Input Glitch Filter register
#define I2C_FLT_FLT_MASK   (0xFU)
 
#define I2C_FLT_FLT_SHIFT   (0U)
 
#define I2C_FLT_FLT(x)   (((uint8_t)(((uint8_t)(x)) << I2C_FLT_FLT_SHIFT)) & I2C_FLT_FLT_MASK)
 
#define I2C_FLT_STARTF_MASK   (0x10U)
 
#define I2C_FLT_STARTF_SHIFT   (4U)
 
#define I2C_FLT_STARTF(x)   (((uint8_t)(((uint8_t)(x)) << I2C_FLT_STARTF_SHIFT)) & I2C_FLT_STARTF_MASK)
 
#define I2C_FLT_SSIE_MASK   (0x20U)
 
#define I2C_FLT_SSIE_SHIFT   (5U)
 
#define I2C_FLT_SSIE(x)   (((uint8_t)(((uint8_t)(x)) << I2C_FLT_SSIE_SHIFT)) & I2C_FLT_SSIE_MASK)
 
#define I2C_FLT_STOPF_MASK   (0x40U)
 
#define I2C_FLT_STOPF_SHIFT   (6U)
 
#define I2C_FLT_STOPF(x)   (((uint8_t)(((uint8_t)(x)) << I2C_FLT_STOPF_SHIFT)) & I2C_FLT_STOPF_MASK)
 
#define I2C_FLT_SHEN_MASK   (0x80U)
 
#define I2C_FLT_SHEN_SHIFT   (7U)
 
#define I2C_FLT_SHEN(x)   (((uint8_t)(((uint8_t)(x)) << I2C_FLT_SHEN_SHIFT)) & I2C_FLT_SHEN_MASK)
 
RA - I2C Range Address register
#define I2C_RA_RAD_MASK   (0xFEU)
 
#define I2C_RA_RAD_SHIFT   (1U)
 
#define I2C_RA_RAD(x)   (((uint8_t)(((uint8_t)(x)) << I2C_RA_RAD_SHIFT)) & I2C_RA_RAD_MASK)
 
SMB - I2C SMBus Control and Status register
#define I2C_SMB_SHTF2IE_MASK   (0x1U)
 
#define I2C_SMB_SHTF2IE_SHIFT   (0U)
 
#define I2C_SMB_SHTF2IE(x)   (((uint8_t)(((uint8_t)(x)) << I2C_SMB_SHTF2IE_SHIFT)) & I2C_SMB_SHTF2IE_MASK)
 
#define I2C_SMB_SHTF2_MASK   (0x2U)
 
#define I2C_SMB_SHTF2_SHIFT   (1U)
 
#define I2C_SMB_SHTF2(x)   (((uint8_t)(((uint8_t)(x)) << I2C_SMB_SHTF2_SHIFT)) & I2C_SMB_SHTF2_MASK)
 
#define I2C_SMB_SHTF1_MASK   (0x4U)
 
#define I2C_SMB_SHTF1_SHIFT   (2U)
 
#define I2C_SMB_SHTF1(x)   (((uint8_t)(((uint8_t)(x)) << I2C_SMB_SHTF1_SHIFT)) & I2C_SMB_SHTF1_MASK)
 
#define I2C_SMB_SLTF_MASK   (0x8U)
 
#define I2C_SMB_SLTF_SHIFT   (3U)
 
#define I2C_SMB_SLTF(x)   (((uint8_t)(((uint8_t)(x)) << I2C_SMB_SLTF_SHIFT)) & I2C_SMB_SLTF_MASK)
 
#define I2C_SMB_TCKSEL_MASK   (0x10U)
 
#define I2C_SMB_TCKSEL_SHIFT   (4U)
 
#define I2C_SMB_TCKSEL(x)   (((uint8_t)(((uint8_t)(x)) << I2C_SMB_TCKSEL_SHIFT)) & I2C_SMB_TCKSEL_MASK)
 
#define I2C_SMB_SIICAEN_MASK   (0x20U)
 
#define I2C_SMB_SIICAEN_SHIFT   (5U)
 
#define I2C_SMB_SIICAEN(x)   (((uint8_t)(((uint8_t)(x)) << I2C_SMB_SIICAEN_SHIFT)) & I2C_SMB_SIICAEN_MASK)
 
#define I2C_SMB_ALERTEN_MASK   (0x40U)
 
#define I2C_SMB_ALERTEN_SHIFT   (6U)
 
#define I2C_SMB_ALERTEN(x)   (((uint8_t)(((uint8_t)(x)) << I2C_SMB_ALERTEN_SHIFT)) & I2C_SMB_ALERTEN_MASK)
 
#define I2C_SMB_FACK_MASK   (0x80U)
 
#define I2C_SMB_FACK_SHIFT   (7U)
 
#define I2C_SMB_FACK(x)   (((uint8_t)(((uint8_t)(x)) << I2C_SMB_FACK_SHIFT)) & I2C_SMB_FACK_MASK)
 
A2 - I2C Address Register 2
#define I2C_A2_SAD_MASK   (0xFEU)
 
#define I2C_A2_SAD_SHIFT   (1U)
 
#define I2C_A2_SAD(x)   (((uint8_t)(((uint8_t)(x)) << I2C_A2_SAD_SHIFT)) & I2C_A2_SAD_MASK)
 
SLTH - I2C SCL Low Timeout Register High
#define I2C_SLTH_SSLT_MASK   (0xFFU)
 
#define I2C_SLTH_SSLT_SHIFT   (0U)
 
#define I2C_SLTH_SSLT(x)   (((uint8_t)(((uint8_t)(x)) << I2C_SLTH_SSLT_SHIFT)) & I2C_SLTH_SSLT_MASK)
 
SLTL - I2C SCL Low Timeout Register Low
#define I2C_SLTL_SSLT_MASK   (0xFFU)
 
#define I2C_SLTL_SSLT_SHIFT   (0U)
 
#define I2C_SLTL_SSLT(x)   (((uint8_t)(((uint8_t)(x)) << I2C_SLTL_SSLT_SHIFT)) & I2C_SLTL_SSLT_MASK)
 
TCSR - SAI Transmit Control Register
#define I2S_TCSR_FRDE_MASK   (0x1U)
 
#define I2S_TCSR_FRDE_SHIFT   (0U)
 
#define I2S_TCSR_FRDE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCSR_FRDE_SHIFT)) & I2S_TCSR_FRDE_MASK)
 
#define I2S_TCSR_FWDE_MASK   (0x2U)
 
#define I2S_TCSR_FWDE_SHIFT   (1U)
 
#define I2S_TCSR_FWDE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCSR_FWDE_SHIFT)) & I2S_TCSR_FWDE_MASK)
 
#define I2S_TCSR_FRIE_MASK   (0x100U)
 
#define I2S_TCSR_FRIE_SHIFT   (8U)
 
#define I2S_TCSR_FRIE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCSR_FRIE_SHIFT)) & I2S_TCSR_FRIE_MASK)
 
#define I2S_TCSR_FWIE_MASK   (0x200U)
 
#define I2S_TCSR_FWIE_SHIFT   (9U)
 
#define I2S_TCSR_FWIE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCSR_FWIE_SHIFT)) & I2S_TCSR_FWIE_MASK)
 
#define I2S_TCSR_FEIE_MASK   (0x400U)
 
#define I2S_TCSR_FEIE_SHIFT   (10U)
 
#define I2S_TCSR_FEIE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCSR_FEIE_SHIFT)) & I2S_TCSR_FEIE_MASK)
 
#define I2S_TCSR_SEIE_MASK   (0x800U)
 
#define I2S_TCSR_SEIE_SHIFT   (11U)
 
#define I2S_TCSR_SEIE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCSR_SEIE_SHIFT)) & I2S_TCSR_SEIE_MASK)
 
#define I2S_TCSR_WSIE_MASK   (0x1000U)
 
#define I2S_TCSR_WSIE_SHIFT   (12U)
 
#define I2S_TCSR_WSIE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCSR_WSIE_SHIFT)) & I2S_TCSR_WSIE_MASK)
 
#define I2S_TCSR_FRF_MASK   (0x10000U)
 
#define I2S_TCSR_FRF_SHIFT   (16U)
 
#define I2S_TCSR_FRF(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCSR_FRF_SHIFT)) & I2S_TCSR_FRF_MASK)
 
#define I2S_TCSR_FWF_MASK   (0x20000U)
 
#define I2S_TCSR_FWF_SHIFT   (17U)
 
#define I2S_TCSR_FWF(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCSR_FWF_SHIFT)) & I2S_TCSR_FWF_MASK)
 
#define I2S_TCSR_FEF_MASK   (0x40000U)
 
#define I2S_TCSR_FEF_SHIFT   (18U)
 
#define I2S_TCSR_FEF(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCSR_FEF_SHIFT)) & I2S_TCSR_FEF_MASK)
 
#define I2S_TCSR_SEF_MASK   (0x80000U)
 
#define I2S_TCSR_SEF_SHIFT   (19U)
 
#define I2S_TCSR_SEF(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCSR_SEF_SHIFT)) & I2S_TCSR_SEF_MASK)
 
#define I2S_TCSR_WSF_MASK   (0x100000U)
 
#define I2S_TCSR_WSF_SHIFT   (20U)
 
#define I2S_TCSR_WSF(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCSR_WSF_SHIFT)) & I2S_TCSR_WSF_MASK)
 
#define I2S_TCSR_SR_MASK   (0x1000000U)
 
#define I2S_TCSR_SR_SHIFT   (24U)
 
#define I2S_TCSR_SR(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCSR_SR_SHIFT)) & I2S_TCSR_SR_MASK)
 
#define I2S_TCSR_FR_MASK   (0x2000000U)
 
#define I2S_TCSR_FR_SHIFT   (25U)
 
#define I2S_TCSR_FR(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCSR_FR_SHIFT)) & I2S_TCSR_FR_MASK)
 
#define I2S_TCSR_BCE_MASK   (0x10000000U)
 
#define I2S_TCSR_BCE_SHIFT   (28U)
 
#define I2S_TCSR_BCE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCSR_BCE_SHIFT)) & I2S_TCSR_BCE_MASK)
 
#define I2S_TCSR_DBGE_MASK   (0x20000000U)
 
#define I2S_TCSR_DBGE_SHIFT   (29U)
 
#define I2S_TCSR_DBGE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCSR_DBGE_SHIFT)) & I2S_TCSR_DBGE_MASK)
 
#define I2S_TCSR_STOPE_MASK   (0x40000000U)
 
#define I2S_TCSR_STOPE_SHIFT   (30U)
 
#define I2S_TCSR_STOPE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCSR_STOPE_SHIFT)) & I2S_TCSR_STOPE_MASK)
 
#define I2S_TCSR_TE_MASK   (0x80000000U)
 
#define I2S_TCSR_TE_SHIFT   (31U)
 
#define I2S_TCSR_TE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCSR_TE_SHIFT)) & I2S_TCSR_TE_MASK)
 
TCR1 - SAI Transmit Configuration 1 Register
#define I2S_TCR1_TFW_MASK   (0x7U)
 
#define I2S_TCR1_TFW_SHIFT   (0U)
 
#define I2S_TCR1_TFW(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCR1_TFW_SHIFT)) & I2S_TCR1_TFW_MASK)
 
TCR2 - SAI Transmit Configuration 2 Register
#define I2S_TCR2_DIV_MASK   (0xFFU)
 
#define I2S_TCR2_DIV_SHIFT   (0U)
 
#define I2S_TCR2_DIV(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCR2_DIV_SHIFT)) & I2S_TCR2_DIV_MASK)
 
#define I2S_TCR2_BCD_MASK   (0x1000000U)
 
#define I2S_TCR2_BCD_SHIFT   (24U)
 
#define I2S_TCR2_BCD(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCR2_BCD_SHIFT)) & I2S_TCR2_BCD_MASK)
 
#define I2S_TCR2_BCP_MASK   (0x2000000U)
 
#define I2S_TCR2_BCP_SHIFT   (25U)
 
#define I2S_TCR2_BCP(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCR2_BCP_SHIFT)) & I2S_TCR2_BCP_MASK)
 
#define I2S_TCR2_MSEL_MASK   (0xC000000U)
 
#define I2S_TCR2_MSEL_SHIFT   (26U)
 
#define I2S_TCR2_MSEL(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCR2_MSEL_SHIFT)) & I2S_TCR2_MSEL_MASK)
 
#define I2S_TCR2_BCI_MASK   (0x10000000U)
 
#define I2S_TCR2_BCI_SHIFT   (28U)
 
#define I2S_TCR2_BCI(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCR2_BCI_SHIFT)) & I2S_TCR2_BCI_MASK)
 
#define I2S_TCR2_BCS_MASK   (0x20000000U)
 
#define I2S_TCR2_BCS_SHIFT   (29U)
 
#define I2S_TCR2_BCS(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCR2_BCS_SHIFT)) & I2S_TCR2_BCS_MASK)
 
#define I2S_TCR2_SYNC_MASK   (0xC0000000U)
 
#define I2S_TCR2_SYNC_SHIFT   (30U)
 
#define I2S_TCR2_SYNC(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCR2_SYNC_SHIFT)) & I2S_TCR2_SYNC_MASK)
 
TCR3 - SAI Transmit Configuration 3 Register
#define I2S_TCR3_WDFL_MASK   (0x1FU)
 
#define I2S_TCR3_WDFL_SHIFT   (0U)
 
#define I2S_TCR3_WDFL(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCR3_WDFL_SHIFT)) & I2S_TCR3_WDFL_MASK)
 
#define I2S_TCR3_TCE_MASK   (0x30000U)
 
#define I2S_TCR3_TCE_SHIFT   (16U)
 
#define I2S_TCR3_TCE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCR3_TCE_SHIFT)) & I2S_TCR3_TCE_MASK)
 
TCR4 - SAI Transmit Configuration 4 Register
#define I2S_TCR4_FSD_MASK   (0x1U)
 
#define I2S_TCR4_FSD_SHIFT   (0U)
 
#define I2S_TCR4_FSD(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCR4_FSD_SHIFT)) & I2S_TCR4_FSD_MASK)
 
#define I2S_TCR4_FSP_MASK   (0x2U)
 
#define I2S_TCR4_FSP_SHIFT   (1U)
 
#define I2S_TCR4_FSP(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCR4_FSP_SHIFT)) & I2S_TCR4_FSP_MASK)
 
#define I2S_TCR4_FSE_MASK   (0x8U)
 
#define I2S_TCR4_FSE_SHIFT   (3U)
 
#define I2S_TCR4_FSE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCR4_FSE_SHIFT)) & I2S_TCR4_FSE_MASK)
 
#define I2S_TCR4_MF_MASK   (0x10U)
 
#define I2S_TCR4_MF_SHIFT   (4U)
 
#define I2S_TCR4_MF(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCR4_MF_SHIFT)) & I2S_TCR4_MF_MASK)
 
#define I2S_TCR4_SYWD_MASK   (0x1F00U)
 
#define I2S_TCR4_SYWD_SHIFT   (8U)
 
#define I2S_TCR4_SYWD(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCR4_SYWD_SHIFT)) & I2S_TCR4_SYWD_MASK)
 
#define I2S_TCR4_FRSZ_MASK   (0x1F0000U)
 
#define I2S_TCR4_FRSZ_SHIFT   (16U)
 
#define I2S_TCR4_FRSZ(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCR4_FRSZ_SHIFT)) & I2S_TCR4_FRSZ_MASK)
 
TCR5 - SAI Transmit Configuration 5 Register
#define I2S_TCR5_FBT_MASK   (0x1F00U)
 
#define I2S_TCR5_FBT_SHIFT   (8U)
 
#define I2S_TCR5_FBT(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCR5_FBT_SHIFT)) & I2S_TCR5_FBT_MASK)
 
#define I2S_TCR5_W0W_MASK   (0x1F0000U)
 
#define I2S_TCR5_W0W_SHIFT   (16U)
 
#define I2S_TCR5_W0W(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCR5_W0W_SHIFT)) & I2S_TCR5_W0W_MASK)
 
#define I2S_TCR5_WNW_MASK   (0x1F000000U)
 
#define I2S_TCR5_WNW_SHIFT   (24U)
 
#define I2S_TCR5_WNW(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TCR5_WNW_SHIFT)) & I2S_TCR5_WNW_MASK)
 
TDR - SAI Transmit Data Register
#define I2S_TDR_TDR_MASK   (0xFFFFFFFFU)
 
#define I2S_TDR_TDR_SHIFT   (0U)
 
#define I2S_TDR_TDR(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TDR_TDR_SHIFT)) & I2S_TDR_TDR_MASK)
 
#define I2S_TDR_COUNT   (2U)
 
TFR - SAI Transmit FIFO Register
#define I2S_TFR_RFP_MASK   (0xFU)
 
#define I2S_TFR_RFP_SHIFT   (0U)
 
#define I2S_TFR_RFP(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TFR_RFP_SHIFT)) & I2S_TFR_RFP_MASK)
 
#define I2S_TFR_WFP_MASK   (0xF0000U)
 
#define I2S_TFR_WFP_SHIFT   (16U)
 
#define I2S_TFR_WFP(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TFR_WFP_SHIFT)) & I2S_TFR_WFP_MASK)
 
#define I2S_TFR_COUNT   (2U)
 
TMR - SAI Transmit Mask Register
#define I2S_TMR_TWM_MASK   (0xFFFFFFFFU)
 
#define I2S_TMR_TWM_SHIFT   (0U)
 
#define I2S_TMR_TWM(x)   (((uint32_t)(((uint32_t)(x)) << I2S_TMR_TWM_SHIFT)) & I2S_TMR_TWM_MASK)
 
RCSR - SAI Receive Control Register
#define I2S_RCSR_FRDE_MASK   (0x1U)
 
#define I2S_RCSR_FRDE_SHIFT   (0U)
 
#define I2S_RCSR_FRDE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCSR_FRDE_SHIFT)) & I2S_RCSR_FRDE_MASK)
 
#define I2S_RCSR_FWDE_MASK   (0x2U)
 
#define I2S_RCSR_FWDE_SHIFT   (1U)
 
#define I2S_RCSR_FWDE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCSR_FWDE_SHIFT)) & I2S_RCSR_FWDE_MASK)
 
#define I2S_RCSR_FRIE_MASK   (0x100U)
 
#define I2S_RCSR_FRIE_SHIFT   (8U)
 
#define I2S_RCSR_FRIE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCSR_FRIE_SHIFT)) & I2S_RCSR_FRIE_MASK)
 
#define I2S_RCSR_FWIE_MASK   (0x200U)
 
#define I2S_RCSR_FWIE_SHIFT   (9U)
 
#define I2S_RCSR_FWIE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCSR_FWIE_SHIFT)) & I2S_RCSR_FWIE_MASK)
 
#define I2S_RCSR_FEIE_MASK   (0x400U)
 
#define I2S_RCSR_FEIE_SHIFT   (10U)
 
#define I2S_RCSR_FEIE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCSR_FEIE_SHIFT)) & I2S_RCSR_FEIE_MASK)
 
#define I2S_RCSR_SEIE_MASK   (0x800U)
 
#define I2S_RCSR_SEIE_SHIFT   (11U)
 
#define I2S_RCSR_SEIE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCSR_SEIE_SHIFT)) & I2S_RCSR_SEIE_MASK)
 
#define I2S_RCSR_WSIE_MASK   (0x1000U)
 
#define I2S_RCSR_WSIE_SHIFT   (12U)
 
#define I2S_RCSR_WSIE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCSR_WSIE_SHIFT)) & I2S_RCSR_WSIE_MASK)
 
#define I2S_RCSR_FRF_MASK   (0x10000U)
 
#define I2S_RCSR_FRF_SHIFT   (16U)
 
#define I2S_RCSR_FRF(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCSR_FRF_SHIFT)) & I2S_RCSR_FRF_MASK)
 
#define I2S_RCSR_FWF_MASK   (0x20000U)
 
#define I2S_RCSR_FWF_SHIFT   (17U)
 
#define I2S_RCSR_FWF(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCSR_FWF_SHIFT)) & I2S_RCSR_FWF_MASK)
 
#define I2S_RCSR_FEF_MASK   (0x40000U)
 
#define I2S_RCSR_FEF_SHIFT   (18U)
 
#define I2S_RCSR_FEF(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCSR_FEF_SHIFT)) & I2S_RCSR_FEF_MASK)
 
#define I2S_RCSR_SEF_MASK   (0x80000U)
 
#define I2S_RCSR_SEF_SHIFT   (19U)
 
#define I2S_RCSR_SEF(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCSR_SEF_SHIFT)) & I2S_RCSR_SEF_MASK)
 
#define I2S_RCSR_WSF_MASK   (0x100000U)
 
#define I2S_RCSR_WSF_SHIFT   (20U)
 
#define I2S_RCSR_WSF(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCSR_WSF_SHIFT)) & I2S_RCSR_WSF_MASK)
 
#define I2S_RCSR_SR_MASK   (0x1000000U)
 
#define I2S_RCSR_SR_SHIFT   (24U)
 
#define I2S_RCSR_SR(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCSR_SR_SHIFT)) & I2S_RCSR_SR_MASK)
 
#define I2S_RCSR_FR_MASK   (0x2000000U)
 
#define I2S_RCSR_FR_SHIFT   (25U)
 
#define I2S_RCSR_FR(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCSR_FR_SHIFT)) & I2S_RCSR_FR_MASK)
 
#define I2S_RCSR_BCE_MASK   (0x10000000U)
 
#define I2S_RCSR_BCE_SHIFT   (28U)
 
#define I2S_RCSR_BCE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCSR_BCE_SHIFT)) & I2S_RCSR_BCE_MASK)
 
#define I2S_RCSR_DBGE_MASK   (0x20000000U)
 
#define I2S_RCSR_DBGE_SHIFT   (29U)
 
#define I2S_RCSR_DBGE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCSR_DBGE_SHIFT)) & I2S_RCSR_DBGE_MASK)
 
#define I2S_RCSR_STOPE_MASK   (0x40000000U)
 
#define I2S_RCSR_STOPE_SHIFT   (30U)
 
#define I2S_RCSR_STOPE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCSR_STOPE_SHIFT)) & I2S_RCSR_STOPE_MASK)
 
#define I2S_RCSR_RE_MASK   (0x80000000U)
 
#define I2S_RCSR_RE_SHIFT   (31U)
 
#define I2S_RCSR_RE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCSR_RE_SHIFT)) & I2S_RCSR_RE_MASK)
 
RCR1 - SAI Receive Configuration 1 Register
#define I2S_RCR1_RFW_MASK   (0x7U)
 
#define I2S_RCR1_RFW_SHIFT   (0U)
 
#define I2S_RCR1_RFW(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCR1_RFW_SHIFT)) & I2S_RCR1_RFW_MASK)
 
RCR2 - SAI Receive Configuration 2 Register
#define I2S_RCR2_DIV_MASK   (0xFFU)
 
#define I2S_RCR2_DIV_SHIFT   (0U)
 
#define I2S_RCR2_DIV(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCR2_DIV_SHIFT)) & I2S_RCR2_DIV_MASK)
 
#define I2S_RCR2_BCD_MASK   (0x1000000U)
 
#define I2S_RCR2_BCD_SHIFT   (24U)
 
#define I2S_RCR2_BCD(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCR2_BCD_SHIFT)) & I2S_RCR2_BCD_MASK)
 
#define I2S_RCR2_BCP_MASK   (0x2000000U)
 
#define I2S_RCR2_BCP_SHIFT   (25U)
 
#define I2S_RCR2_BCP(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCR2_BCP_SHIFT)) & I2S_RCR2_BCP_MASK)
 
#define I2S_RCR2_MSEL_MASK   (0xC000000U)
 
#define I2S_RCR2_MSEL_SHIFT   (26U)
 
#define I2S_RCR2_MSEL(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCR2_MSEL_SHIFT)) & I2S_RCR2_MSEL_MASK)
 
#define I2S_RCR2_BCI_MASK   (0x10000000U)
 
#define I2S_RCR2_BCI_SHIFT   (28U)
 
#define I2S_RCR2_BCI(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCR2_BCI_SHIFT)) & I2S_RCR2_BCI_MASK)
 
#define I2S_RCR2_BCS_MASK   (0x20000000U)
 
#define I2S_RCR2_BCS_SHIFT   (29U)
 
#define I2S_RCR2_BCS(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCR2_BCS_SHIFT)) & I2S_RCR2_BCS_MASK)
 
#define I2S_RCR2_SYNC_MASK   (0xC0000000U)
 
#define I2S_RCR2_SYNC_SHIFT   (30U)
 
#define I2S_RCR2_SYNC(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCR2_SYNC_SHIFT)) & I2S_RCR2_SYNC_MASK)
 
RCR3 - SAI Receive Configuration 3 Register
#define I2S_RCR3_WDFL_MASK   (0x1FU)
 
#define I2S_RCR3_WDFL_SHIFT   (0U)
 
#define I2S_RCR3_WDFL(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCR3_WDFL_SHIFT)) & I2S_RCR3_WDFL_MASK)
 
#define I2S_RCR3_RCE_MASK   (0x30000U)
 
#define I2S_RCR3_RCE_SHIFT   (16U)
 
#define I2S_RCR3_RCE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCR3_RCE_SHIFT)) & I2S_RCR3_RCE_MASK)
 
RCR4 - SAI Receive Configuration 4 Register
#define I2S_RCR4_FSD_MASK   (0x1U)
 
#define I2S_RCR4_FSD_SHIFT   (0U)
 
#define I2S_RCR4_FSD(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCR4_FSD_SHIFT)) & I2S_RCR4_FSD_MASK)
 
#define I2S_RCR4_FSP_MASK   (0x2U)
 
#define I2S_RCR4_FSP_SHIFT   (1U)
 
#define I2S_RCR4_FSP(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCR4_FSP_SHIFT)) & I2S_RCR4_FSP_MASK)
 
#define I2S_RCR4_FSE_MASK   (0x8U)
 
#define I2S_RCR4_FSE_SHIFT   (3U)
 
#define I2S_RCR4_FSE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCR4_FSE_SHIFT)) & I2S_RCR4_FSE_MASK)
 
#define I2S_RCR4_MF_MASK   (0x10U)
 
#define I2S_RCR4_MF_SHIFT   (4U)
 
#define I2S_RCR4_MF(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCR4_MF_SHIFT)) & I2S_RCR4_MF_MASK)
 
#define I2S_RCR4_SYWD_MASK   (0x1F00U)
 
#define I2S_RCR4_SYWD_SHIFT   (8U)
 
#define I2S_RCR4_SYWD(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCR4_SYWD_SHIFT)) & I2S_RCR4_SYWD_MASK)
 
#define I2S_RCR4_FRSZ_MASK   (0x1F0000U)
 
#define I2S_RCR4_FRSZ_SHIFT   (16U)
 
#define I2S_RCR4_FRSZ(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCR4_FRSZ_SHIFT)) & I2S_RCR4_FRSZ_MASK)
 
RCR5 - SAI Receive Configuration 5 Register
#define I2S_RCR5_FBT_MASK   (0x1F00U)
 
#define I2S_RCR5_FBT_SHIFT   (8U)
 
#define I2S_RCR5_FBT(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCR5_FBT_SHIFT)) & I2S_RCR5_FBT_MASK)
 
#define I2S_RCR5_W0W_MASK   (0x1F0000U)
 
#define I2S_RCR5_W0W_SHIFT   (16U)
 
#define I2S_RCR5_W0W(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCR5_W0W_SHIFT)) & I2S_RCR5_W0W_MASK)
 
#define I2S_RCR5_WNW_MASK   (0x1F000000U)
 
#define I2S_RCR5_WNW_SHIFT   (24U)
 
#define I2S_RCR5_WNW(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RCR5_WNW_SHIFT)) & I2S_RCR5_WNW_MASK)
 
RDR - SAI Receive Data Register
#define I2S_RDR_RDR_MASK   (0xFFFFFFFFU)
 
#define I2S_RDR_RDR_SHIFT   (0U)
 
#define I2S_RDR_RDR(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RDR_RDR_SHIFT)) & I2S_RDR_RDR_MASK)
 
#define I2S_RDR_COUNT   (2U)
 
RFR - SAI Receive FIFO Register
#define I2S_RFR_RFP_MASK   (0xFU)
 
#define I2S_RFR_RFP_SHIFT   (0U)
 
#define I2S_RFR_RFP(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RFR_RFP_SHIFT)) & I2S_RFR_RFP_MASK)
 
#define I2S_RFR_WFP_MASK   (0xF0000U)
 
#define I2S_RFR_WFP_SHIFT   (16U)
 
#define I2S_RFR_WFP(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RFR_WFP_SHIFT)) & I2S_RFR_WFP_MASK)
 
#define I2S_RFR_COUNT   (2U)
 
RMR - SAI Receive Mask Register
#define I2S_RMR_RWM_MASK   (0xFFFFFFFFU)
 
#define I2S_RMR_RWM_SHIFT   (0U)
 
#define I2S_RMR_RWM(x)   (((uint32_t)(((uint32_t)(x)) << I2S_RMR_RWM_SHIFT)) & I2S_RMR_RWM_MASK)
 
MCR - SAI MCLK Control Register
#define I2S_MCR_MICS_MASK   (0x3000000U)
 
#define I2S_MCR_MICS_SHIFT   (24U)
 
#define I2S_MCR_MICS(x)   (((uint32_t)(((uint32_t)(x)) << I2S_MCR_MICS_SHIFT)) & I2S_MCR_MICS_MASK)
 
#define I2S_MCR_MOE_MASK   (0x40000000U)
 
#define I2S_MCR_MOE_SHIFT   (30U)
 
#define I2S_MCR_MOE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_MCR_MOE_SHIFT)) & I2S_MCR_MOE_MASK)
 
#define I2S_MCR_DUF_MASK   (0x80000000U)
 
#define I2S_MCR_DUF_SHIFT   (31U)
 
#define I2S_MCR_DUF(x)   (((uint32_t)(((uint32_t)(x)) << I2S_MCR_DUF_SHIFT)) & I2S_MCR_DUF_MASK)
 
MDR - SAI MCLK Divide Register
#define I2S_MDR_DIVIDE_MASK   (0xFFFU)
 
#define I2S_MDR_DIVIDE_SHIFT   (0U)
 
#define I2S_MDR_DIVIDE(x)   (((uint32_t)(((uint32_t)(x)) << I2S_MDR_DIVIDE_SHIFT)) & I2S_MDR_DIVIDE_MASK)
 
#define I2S_MDR_FRACT_MASK   (0xFF000U)
 
#define I2S_MDR_FRACT_SHIFT   (12U)
 
#define I2S_MDR_FRACT(x)   (((uint32_t)(((uint32_t)(x)) << I2S_MDR_FRACT_SHIFT)) & I2S_MDR_FRACT_MASK)
 
PE1 - LLWU Pin Enable 1 register
#define LLWU_PE1_WUPE0_MASK   (0x3U)
 
#define LLWU_PE1_WUPE0_SHIFT   (0U)
 
#define LLWU_PE1_WUPE0(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_PE1_WUPE0_SHIFT)) & LLWU_PE1_WUPE0_MASK)
 
#define LLWU_PE1_WUPE1_MASK   (0xCU)
 
#define LLWU_PE1_WUPE1_SHIFT   (2U)
 
#define LLWU_PE1_WUPE1(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_PE1_WUPE1_SHIFT)) & LLWU_PE1_WUPE1_MASK)
 
#define LLWU_PE1_WUPE2_MASK   (0x30U)
 
#define LLWU_PE1_WUPE2_SHIFT   (4U)
 
#define LLWU_PE1_WUPE2(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_PE1_WUPE2_SHIFT)) & LLWU_PE1_WUPE2_MASK)
 
#define LLWU_PE1_WUPE3_MASK   (0xC0U)
 
#define LLWU_PE1_WUPE3_SHIFT   (6U)
 
#define LLWU_PE1_WUPE3(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_PE1_WUPE3_SHIFT)) & LLWU_PE1_WUPE3_MASK)
 
PE2 - LLWU Pin Enable 2 register
#define LLWU_PE2_WUPE4_MASK   (0x3U)
 
#define LLWU_PE2_WUPE4_SHIFT   (0U)
 
#define LLWU_PE2_WUPE4(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_PE2_WUPE4_SHIFT)) & LLWU_PE2_WUPE4_MASK)
 
#define LLWU_PE2_WUPE5_MASK   (0xCU)
 
#define LLWU_PE2_WUPE5_SHIFT   (2U)
 
#define LLWU_PE2_WUPE5(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_PE2_WUPE5_SHIFT)) & LLWU_PE2_WUPE5_MASK)
 
#define LLWU_PE2_WUPE6_MASK   (0x30U)
 
#define LLWU_PE2_WUPE6_SHIFT   (4U)
 
#define LLWU_PE2_WUPE6(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_PE2_WUPE6_SHIFT)) & LLWU_PE2_WUPE6_MASK)
 
#define LLWU_PE2_WUPE7_MASK   (0xC0U)
 
#define LLWU_PE2_WUPE7_SHIFT   (6U)
 
#define LLWU_PE2_WUPE7(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_PE2_WUPE7_SHIFT)) & LLWU_PE2_WUPE7_MASK)
 
PE3 - LLWU Pin Enable 3 register
#define LLWU_PE3_WUPE8_MASK   (0x3U)
 
#define LLWU_PE3_WUPE8_SHIFT   (0U)
 
#define LLWU_PE3_WUPE8(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_PE3_WUPE8_SHIFT)) & LLWU_PE3_WUPE8_MASK)
 
#define LLWU_PE3_WUPE9_MASK   (0xCU)
 
#define LLWU_PE3_WUPE9_SHIFT   (2U)
 
#define LLWU_PE3_WUPE9(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_PE3_WUPE9_SHIFT)) & LLWU_PE3_WUPE9_MASK)
 
#define LLWU_PE3_WUPE10_MASK   (0x30U)
 
#define LLWU_PE3_WUPE10_SHIFT   (4U)
 
#define LLWU_PE3_WUPE10(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_PE3_WUPE10_SHIFT)) & LLWU_PE3_WUPE10_MASK)
 
#define LLWU_PE3_WUPE11_MASK   (0xC0U)
 
#define LLWU_PE3_WUPE11_SHIFT   (6U)
 
#define LLWU_PE3_WUPE11(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_PE3_WUPE11_SHIFT)) & LLWU_PE3_WUPE11_MASK)
 
PE4 - LLWU Pin Enable 4 register
#define LLWU_PE4_WUPE12_MASK   (0x3U)
 
#define LLWU_PE4_WUPE12_SHIFT   (0U)
 
#define LLWU_PE4_WUPE12(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_PE4_WUPE12_SHIFT)) & LLWU_PE4_WUPE12_MASK)
 
#define LLWU_PE4_WUPE13_MASK   (0xCU)
 
#define LLWU_PE4_WUPE13_SHIFT   (2U)
 
#define LLWU_PE4_WUPE13(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_PE4_WUPE13_SHIFT)) & LLWU_PE4_WUPE13_MASK)
 
#define LLWU_PE4_WUPE14_MASK   (0x30U)
 
#define LLWU_PE4_WUPE14_SHIFT   (4U)
 
#define LLWU_PE4_WUPE14(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_PE4_WUPE14_SHIFT)) & LLWU_PE4_WUPE14_MASK)
 
#define LLWU_PE4_WUPE15_MASK   (0xC0U)
 
#define LLWU_PE4_WUPE15_SHIFT   (6U)
 
#define LLWU_PE4_WUPE15(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_PE4_WUPE15_SHIFT)) & LLWU_PE4_WUPE15_MASK)
 
ME - LLWU Module Enable register
#define LLWU_ME_WUME0_MASK   (0x1U)
 
#define LLWU_ME_WUME0_SHIFT   (0U)
 
#define LLWU_ME_WUME0(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_ME_WUME0_SHIFT)) & LLWU_ME_WUME0_MASK)
 
#define LLWU_ME_WUME1_MASK   (0x2U)
 
#define LLWU_ME_WUME1_SHIFT   (1U)
 
#define LLWU_ME_WUME1(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_ME_WUME1_SHIFT)) & LLWU_ME_WUME1_MASK)
 
#define LLWU_ME_WUME2_MASK   (0x4U)
 
#define LLWU_ME_WUME2_SHIFT   (2U)
 
#define LLWU_ME_WUME2(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_ME_WUME2_SHIFT)) & LLWU_ME_WUME2_MASK)
 
#define LLWU_ME_WUME3_MASK   (0x8U)
 
#define LLWU_ME_WUME3_SHIFT   (3U)
 
#define LLWU_ME_WUME3(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_ME_WUME3_SHIFT)) & LLWU_ME_WUME3_MASK)
 
#define LLWU_ME_WUME4_MASK   (0x10U)
 
#define LLWU_ME_WUME4_SHIFT   (4U)
 
#define LLWU_ME_WUME4(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_ME_WUME4_SHIFT)) & LLWU_ME_WUME4_MASK)
 
#define LLWU_ME_WUME5_MASK   (0x20U)
 
#define LLWU_ME_WUME5_SHIFT   (5U)
 
#define LLWU_ME_WUME5(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_ME_WUME5_SHIFT)) & LLWU_ME_WUME5_MASK)
 
#define LLWU_ME_WUME6_MASK   (0x40U)
 
#define LLWU_ME_WUME6_SHIFT   (6U)
 
#define LLWU_ME_WUME6(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_ME_WUME6_SHIFT)) & LLWU_ME_WUME6_MASK)
 
#define LLWU_ME_WUME7_MASK   (0x80U)
 
#define LLWU_ME_WUME7_SHIFT   (7U)
 
#define LLWU_ME_WUME7(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_ME_WUME7_SHIFT)) & LLWU_ME_WUME7_MASK)
 
F1 - LLWU Flag 1 register
#define LLWU_F1_WUF0_MASK   (0x1U)
 
#define LLWU_F1_WUF0_SHIFT   (0U)
 
#define LLWU_F1_WUF0(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_F1_WUF0_SHIFT)) & LLWU_F1_WUF0_MASK)
 
#define LLWU_F1_WUF1_MASK   (0x2U)
 
#define LLWU_F1_WUF1_SHIFT   (1U)
 
#define LLWU_F1_WUF1(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_F1_WUF1_SHIFT)) & LLWU_F1_WUF1_MASK)
 
#define LLWU_F1_WUF2_MASK   (0x4U)
 
#define LLWU_F1_WUF2_SHIFT   (2U)
 
#define LLWU_F1_WUF2(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_F1_WUF2_SHIFT)) & LLWU_F1_WUF2_MASK)
 
#define LLWU_F1_WUF3_MASK   (0x8U)
 
#define LLWU_F1_WUF3_SHIFT   (3U)
 
#define LLWU_F1_WUF3(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_F1_WUF3_SHIFT)) & LLWU_F1_WUF3_MASK)
 
#define LLWU_F1_WUF4_MASK   (0x10U)
 
#define LLWU_F1_WUF4_SHIFT   (4U)
 
#define LLWU_F1_WUF4(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_F1_WUF4_SHIFT)) & LLWU_F1_WUF4_MASK)
 
#define LLWU_F1_WUF5_MASK   (0x20U)
 
#define LLWU_F1_WUF5_SHIFT   (5U)
 
#define LLWU_F1_WUF5(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_F1_WUF5_SHIFT)) & LLWU_F1_WUF5_MASK)
 
#define LLWU_F1_WUF6_MASK   (0x40U)
 
#define LLWU_F1_WUF6_SHIFT   (6U)
 
#define LLWU_F1_WUF6(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_F1_WUF6_SHIFT)) & LLWU_F1_WUF6_MASK)
 
#define LLWU_F1_WUF7_MASK   (0x80U)
 
#define LLWU_F1_WUF7_SHIFT   (7U)
 
#define LLWU_F1_WUF7(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_F1_WUF7_SHIFT)) & LLWU_F1_WUF7_MASK)
 
F2 - LLWU Flag 2 register
#define LLWU_F2_WUF8_MASK   (0x1U)
 
#define LLWU_F2_WUF8_SHIFT   (0U)
 
#define LLWU_F2_WUF8(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_F2_WUF8_SHIFT)) & LLWU_F2_WUF8_MASK)
 
#define LLWU_F2_WUF9_MASK   (0x2U)
 
#define LLWU_F2_WUF9_SHIFT   (1U)
 
#define LLWU_F2_WUF9(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_F2_WUF9_SHIFT)) & LLWU_F2_WUF9_MASK)
 
#define LLWU_F2_WUF10_MASK   (0x4U)
 
#define LLWU_F2_WUF10_SHIFT   (2U)
 
#define LLWU_F2_WUF10(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_F2_WUF10_SHIFT)) & LLWU_F2_WUF10_MASK)
 
#define LLWU_F2_WUF11_MASK   (0x8U)
 
#define LLWU_F2_WUF11_SHIFT   (3U)
 
#define LLWU_F2_WUF11(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_F2_WUF11_SHIFT)) & LLWU_F2_WUF11_MASK)
 
#define LLWU_F2_WUF12_MASK   (0x10U)
 
#define LLWU_F2_WUF12_SHIFT   (4U)
 
#define LLWU_F2_WUF12(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_F2_WUF12_SHIFT)) & LLWU_F2_WUF12_MASK)
 
#define LLWU_F2_WUF13_MASK   (0x20U)
 
#define LLWU_F2_WUF13_SHIFT   (5U)
 
#define LLWU_F2_WUF13(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_F2_WUF13_SHIFT)) & LLWU_F2_WUF13_MASK)
 
#define LLWU_F2_WUF14_MASK   (0x40U)
 
#define LLWU_F2_WUF14_SHIFT   (6U)
 
#define LLWU_F2_WUF14(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_F2_WUF14_SHIFT)) & LLWU_F2_WUF14_MASK)
 
#define LLWU_F2_WUF15_MASK   (0x80U)
 
#define LLWU_F2_WUF15_SHIFT   (7U)
 
#define LLWU_F2_WUF15(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_F2_WUF15_SHIFT)) & LLWU_F2_WUF15_MASK)
 
F3 - LLWU Flag 3 register
#define LLWU_F3_MWUF0_MASK   (0x1U)
 
#define LLWU_F3_MWUF0_SHIFT   (0U)
 
#define LLWU_F3_MWUF0(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_F3_MWUF0_SHIFT)) & LLWU_F3_MWUF0_MASK)
 
#define LLWU_F3_MWUF1_MASK   (0x2U)
 
#define LLWU_F3_MWUF1_SHIFT   (1U)
 
#define LLWU_F3_MWUF1(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_F3_MWUF1_SHIFT)) & LLWU_F3_MWUF1_MASK)
 
#define LLWU_F3_MWUF2_MASK   (0x4U)
 
#define LLWU_F3_MWUF2_SHIFT   (2U)
 
#define LLWU_F3_MWUF2(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_F3_MWUF2_SHIFT)) & LLWU_F3_MWUF2_MASK)
 
#define LLWU_F3_MWUF3_MASK   (0x8U)
 
#define LLWU_F3_MWUF3_SHIFT   (3U)
 
#define LLWU_F3_MWUF3(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_F3_MWUF3_SHIFT)) & LLWU_F3_MWUF3_MASK)
 
#define LLWU_F3_MWUF4_MASK   (0x10U)
 
#define LLWU_F3_MWUF4_SHIFT   (4U)
 
#define LLWU_F3_MWUF4(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_F3_MWUF4_SHIFT)) & LLWU_F3_MWUF4_MASK)
 
#define LLWU_F3_MWUF5_MASK   (0x20U)
 
#define LLWU_F3_MWUF5_SHIFT   (5U)
 
#define LLWU_F3_MWUF5(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_F3_MWUF5_SHIFT)) & LLWU_F3_MWUF5_MASK)
 
#define LLWU_F3_MWUF6_MASK   (0x40U)
 
#define LLWU_F3_MWUF6_SHIFT   (6U)
 
#define LLWU_F3_MWUF6(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_F3_MWUF6_SHIFT)) & LLWU_F3_MWUF6_MASK)
 
#define LLWU_F3_MWUF7_MASK   (0x80U)
 
#define LLWU_F3_MWUF7_SHIFT   (7U)
 
#define LLWU_F3_MWUF7(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_F3_MWUF7_SHIFT)) & LLWU_F3_MWUF7_MASK)
 
FILT1 - LLWU Pin Filter 1 register
#define LLWU_FILT1_FILTSEL_MASK   (0xFU)
 
#define LLWU_FILT1_FILTSEL_SHIFT   (0U)
 
#define LLWU_FILT1_FILTSEL(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_FILT1_FILTSEL_SHIFT)) & LLWU_FILT1_FILTSEL_MASK)
 
#define LLWU_FILT1_FILTE_MASK   (0x60U)
 
#define LLWU_FILT1_FILTE_SHIFT   (5U)
 
#define LLWU_FILT1_FILTE(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_FILT1_FILTE_SHIFT)) & LLWU_FILT1_FILTE_MASK)
 
#define LLWU_FILT1_FILTF_MASK   (0x80U)
 
#define LLWU_FILT1_FILTF_SHIFT   (7U)
 
#define LLWU_FILT1_FILTF(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_FILT1_FILTF_SHIFT)) & LLWU_FILT1_FILTF_MASK)
 
FILT2 - LLWU Pin Filter 2 register
#define LLWU_FILT2_FILTSEL_MASK   (0xFU)
 
#define LLWU_FILT2_FILTSEL_SHIFT   (0U)
 
#define LLWU_FILT2_FILTSEL(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_FILT2_FILTSEL_SHIFT)) & LLWU_FILT2_FILTSEL_MASK)
 
#define LLWU_FILT2_FILTE_MASK   (0x60U)
 
#define LLWU_FILT2_FILTE_SHIFT   (5U)
 
#define LLWU_FILT2_FILTE(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_FILT2_FILTE_SHIFT)) & LLWU_FILT2_FILTE_MASK)
 
#define LLWU_FILT2_FILTF_MASK   (0x80U)
 
#define LLWU_FILT2_FILTF_SHIFT   (7U)
 
#define LLWU_FILT2_FILTF(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_FILT2_FILTF_SHIFT)) & LLWU_FILT2_FILTF_MASK)
 
RST - LLWU Reset Enable register
#define LLWU_RST_RSTFILT_MASK   (0x1U)
 
#define LLWU_RST_RSTFILT_SHIFT   (0U)
 
#define LLWU_RST_RSTFILT(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_RST_RSTFILT_SHIFT)) & LLWU_RST_RSTFILT_MASK)
 
#define LLWU_RST_LLRSTE_MASK   (0x2U)
 
#define LLWU_RST_LLRSTE_SHIFT   (1U)
 
#define LLWU_RST_LLRSTE(x)   (((uint8_t)(((uint8_t)(x)) << LLWU_RST_LLRSTE_SHIFT)) & LLWU_RST_LLRSTE_MASK)
 
CSR - Low Power Timer Control Status Register
#define LPTMR_CSR_TEN_MASK   (0x1U)
 
#define LPTMR_CSR_TEN_SHIFT   (0U)
 
#define LPTMR_CSR_TEN(x)   (((uint32_t)(((uint32_t)(x)) << LPTMR_CSR_TEN_SHIFT)) & LPTMR_CSR_TEN_MASK)
 
#define LPTMR_CSR_TMS_MASK   (0x2U)
 
#define LPTMR_CSR_TMS_SHIFT   (1U)
 
#define LPTMR_CSR_TMS(x)   (((uint32_t)(((uint32_t)(x)) << LPTMR_CSR_TMS_SHIFT)) & LPTMR_CSR_TMS_MASK)
 
#define LPTMR_CSR_TFC_MASK   (0x4U)
 
#define LPTMR_CSR_TFC_SHIFT   (2U)
 
#define LPTMR_CSR_TFC(x)   (((uint32_t)(((uint32_t)(x)) << LPTMR_CSR_TFC_SHIFT)) & LPTMR_CSR_TFC_MASK)
 
#define LPTMR_CSR_TPP_MASK   (0x8U)
 
#define LPTMR_CSR_TPP_SHIFT   (3U)
 
#define LPTMR_CSR_TPP(x)   (((uint32_t)(((uint32_t)(x)) << LPTMR_CSR_TPP_SHIFT)) & LPTMR_CSR_TPP_MASK)
 
#define LPTMR_CSR_TPS_MASK   (0x30U)
 
#define LPTMR_CSR_TPS_SHIFT   (4U)
 
#define LPTMR_CSR_TPS(x)   (((uint32_t)(((uint32_t)(x)) << LPTMR_CSR_TPS_SHIFT)) & LPTMR_CSR_TPS_MASK)
 
#define LPTMR_CSR_TIE_MASK   (0x40U)
 
#define LPTMR_CSR_TIE_SHIFT   (6U)
 
#define LPTMR_CSR_TIE(x)   (((uint32_t)(((uint32_t)(x)) << LPTMR_CSR_TIE_SHIFT)) & LPTMR_CSR_TIE_MASK)
 
#define LPTMR_CSR_TCF_MASK   (0x80U)
 
#define LPTMR_CSR_TCF_SHIFT   (7U)
 
#define LPTMR_CSR_TCF(x)   (((uint32_t)(((uint32_t)(x)) << LPTMR_CSR_TCF_SHIFT)) & LPTMR_CSR_TCF_MASK)
 
PSR - Low Power Timer Prescale Register
#define LPTMR_PSR_PCS_MASK   (0x3U)
 
#define LPTMR_PSR_PCS_SHIFT   (0U)
 
#define LPTMR_PSR_PCS(x)   (((uint32_t)(((uint32_t)(x)) << LPTMR_PSR_PCS_SHIFT)) & LPTMR_PSR_PCS_MASK)
 
#define LPTMR_PSR_PBYP_MASK   (0x4U)
 
#define LPTMR_PSR_PBYP_SHIFT   (2U)
 
#define LPTMR_PSR_PBYP(x)   (((uint32_t)(((uint32_t)(x)) << LPTMR_PSR_PBYP_SHIFT)) & LPTMR_PSR_PBYP_MASK)
 
#define LPTMR_PSR_PRESCALE_MASK   (0x78U)
 
#define LPTMR_PSR_PRESCALE_SHIFT   (3U)
 
#define LPTMR_PSR_PRESCALE(x)   (((uint32_t)(((uint32_t)(x)) << LPTMR_PSR_PRESCALE_SHIFT)) & LPTMR_PSR_PRESCALE_MASK)
 
CMR - Low Power Timer Compare Register
#define LPTMR_CMR_COMPARE_MASK   (0xFFFFU)
 
#define LPTMR_CMR_COMPARE_SHIFT   (0U)
 
#define LPTMR_CMR_COMPARE(x)   (((uint32_t)(((uint32_t)(x)) << LPTMR_CMR_COMPARE_SHIFT)) & LPTMR_CMR_COMPARE_MASK)
 
CNR - Low Power Timer Counter Register
#define LPTMR_CNR_COUNTER_MASK   (0xFFFFU)
 
#define LPTMR_CNR_COUNTER_SHIFT   (0U)
 
#define LPTMR_CNR_COUNTER(x)   (((uint32_t)(((uint32_t)(x)) << LPTMR_CNR_COUNTER_SHIFT)) & LPTMR_CNR_COUNTER_MASK)
 
C1 - MCG Control 1 Register
#define MCG_C1_IREFSTEN_MASK   (0x1U)
 
#define MCG_C1_IREFSTEN_SHIFT   (0U)
 
#define MCG_C1_IREFSTEN(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C1_IREFSTEN_SHIFT)) & MCG_C1_IREFSTEN_MASK)
 
#define MCG_C1_IRCLKEN_MASK   (0x2U)
 
#define MCG_C1_IRCLKEN_SHIFT   (1U)
 
#define MCG_C1_IRCLKEN(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C1_IRCLKEN_SHIFT)) & MCG_C1_IRCLKEN_MASK)
 
#define MCG_C1_IREFS_MASK   (0x4U)
 
#define MCG_C1_IREFS_SHIFT   (2U)
 
#define MCG_C1_IREFS(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C1_IREFS_SHIFT)) & MCG_C1_IREFS_MASK)
 
#define MCG_C1_FRDIV_MASK   (0x38U)
 
#define MCG_C1_FRDIV_SHIFT   (3U)
 
#define MCG_C1_FRDIV(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C1_FRDIV_SHIFT)) & MCG_C1_FRDIV_MASK)
 
#define MCG_C1_CLKS_MASK   (0xC0U)
 
#define MCG_C1_CLKS_SHIFT   (6U)
 
#define MCG_C1_CLKS(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C1_CLKS_SHIFT)) & MCG_C1_CLKS_MASK)
 
C2 - MCG Control 2 Register
#define MCG_C2_IRCS_MASK   (0x1U)
 
#define MCG_C2_IRCS_SHIFT   (0U)
 
#define MCG_C2_IRCS(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C2_IRCS_SHIFT)) & MCG_C2_IRCS_MASK)
 
#define MCG_C2_LP_MASK   (0x2U)
 
#define MCG_C2_LP_SHIFT   (1U)
 
#define MCG_C2_LP(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C2_LP_SHIFT)) & MCG_C2_LP_MASK)
 
#define MCG_C2_EREFS_MASK   (0x4U)
 
#define MCG_C2_EREFS_SHIFT   (2U)
 
#define MCG_C2_EREFS(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C2_EREFS_SHIFT)) & MCG_C2_EREFS_MASK)
 
#define MCG_C2_HGO_MASK   (0x8U)
 
#define MCG_C2_HGO_SHIFT   (3U)
 
#define MCG_C2_HGO(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C2_HGO_SHIFT)) & MCG_C2_HGO_MASK)
 
#define MCG_C2_RANGE_MASK   (0x30U)
 
#define MCG_C2_RANGE_SHIFT   (4U)
 
#define MCG_C2_RANGE(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C2_RANGE_SHIFT)) & MCG_C2_RANGE_MASK)
 
#define MCG_C2_FCFTRIM_MASK   (0x40U)
 
#define MCG_C2_FCFTRIM_SHIFT   (6U)
 
#define MCG_C2_FCFTRIM(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C2_FCFTRIM_SHIFT)) & MCG_C2_FCFTRIM_MASK)
 
#define MCG_C2_LOCRE0_MASK   (0x80U)
 
#define MCG_C2_LOCRE0_SHIFT   (7U)
 
#define MCG_C2_LOCRE0(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C2_LOCRE0_SHIFT)) & MCG_C2_LOCRE0_MASK)
 
C3 - MCG Control 3 Register
#define MCG_C3_SCTRIM_MASK   (0xFFU)
 
#define MCG_C3_SCTRIM_SHIFT   (0U)
 
#define MCG_C3_SCTRIM(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C3_SCTRIM_SHIFT)) & MCG_C3_SCTRIM_MASK)
 
C4 - MCG Control 4 Register
#define MCG_C4_SCFTRIM_MASK   (0x1U)
 
#define MCG_C4_SCFTRIM_SHIFT   (0U)
 
#define MCG_C4_SCFTRIM(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C4_SCFTRIM_SHIFT)) & MCG_C4_SCFTRIM_MASK)
 
#define MCG_C4_FCTRIM_MASK   (0x1EU)
 
#define MCG_C4_FCTRIM_SHIFT   (1U)
 
#define MCG_C4_FCTRIM(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C4_FCTRIM_SHIFT)) & MCG_C4_FCTRIM_MASK)
 
#define MCG_C4_DRST_DRS_MASK   (0x60U)
 
#define MCG_C4_DRST_DRS_SHIFT   (5U)
 
#define MCG_C4_DRST_DRS(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C4_DRST_DRS_SHIFT)) & MCG_C4_DRST_DRS_MASK)
 
#define MCG_C4_DMX32_MASK   (0x80U)
 
#define MCG_C4_DMX32_SHIFT   (7U)
 
#define MCG_C4_DMX32(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C4_DMX32_SHIFT)) & MCG_C4_DMX32_MASK)
 
C5 - MCG Control 5 Register
#define MCG_C5_PRDIV0_MASK   (0x1FU)
 
#define MCG_C5_PRDIV0_SHIFT   (0U)
 
#define MCG_C5_PRDIV0(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C5_PRDIV0_SHIFT)) & MCG_C5_PRDIV0_MASK)
 
#define MCG_C5_PLLSTEN0_MASK   (0x20U)
 
#define MCG_C5_PLLSTEN0_SHIFT   (5U)
 
#define MCG_C5_PLLSTEN0(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C5_PLLSTEN0_SHIFT)) & MCG_C5_PLLSTEN0_MASK)
 
#define MCG_C5_PLLCLKEN0_MASK   (0x40U)
 
#define MCG_C5_PLLCLKEN0_SHIFT   (6U)
 
#define MCG_C5_PLLCLKEN0(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C5_PLLCLKEN0_SHIFT)) & MCG_C5_PLLCLKEN0_MASK)
 
C6 - MCG Control 6 Register
#define MCG_C6_VDIV0_MASK   (0x1FU)
 
#define MCG_C6_VDIV0_SHIFT   (0U)
 
#define MCG_C6_VDIV0(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C6_VDIV0_SHIFT)) & MCG_C6_VDIV0_MASK)
 
#define MCG_C6_CME0_MASK   (0x20U)
 
#define MCG_C6_CME0_SHIFT   (5U)
 
#define MCG_C6_CME0(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C6_CME0_SHIFT)) & MCG_C6_CME0_MASK)
 
#define MCG_C6_PLLS_MASK   (0x40U)
 
#define MCG_C6_PLLS_SHIFT   (6U)
 
#define MCG_C6_PLLS(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C6_PLLS_SHIFT)) & MCG_C6_PLLS_MASK)
 
#define MCG_C6_LOLIE0_MASK   (0x80U)
 
#define MCG_C6_LOLIE0_SHIFT   (7U)
 
#define MCG_C6_LOLIE0(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C6_LOLIE0_SHIFT)) & MCG_C6_LOLIE0_MASK)
 
S - MCG Status Register
#define MCG_S_IRCST_MASK   (0x1U)
 
#define MCG_S_IRCST_SHIFT   (0U)
 
#define MCG_S_IRCST(x)   (((uint8_t)(((uint8_t)(x)) << MCG_S_IRCST_SHIFT)) & MCG_S_IRCST_MASK)
 
#define MCG_S_OSCINIT0_MASK   (0x2U)
 
#define MCG_S_OSCINIT0_SHIFT   (1U)
 
#define MCG_S_OSCINIT0(x)   (((uint8_t)(((uint8_t)(x)) << MCG_S_OSCINIT0_SHIFT)) & MCG_S_OSCINIT0_MASK)
 
#define MCG_S_CLKST_MASK   (0xCU)
 
#define MCG_S_CLKST_SHIFT   (2U)
 
#define MCG_S_CLKST(x)   (((uint8_t)(((uint8_t)(x)) << MCG_S_CLKST_SHIFT)) & MCG_S_CLKST_MASK)
 
#define MCG_S_IREFST_MASK   (0x10U)
 
#define MCG_S_IREFST_SHIFT   (4U)
 
#define MCG_S_IREFST(x)   (((uint8_t)(((uint8_t)(x)) << MCG_S_IREFST_SHIFT)) & MCG_S_IREFST_MASK)
 
#define MCG_S_PLLST_MASK   (0x20U)
 
#define MCG_S_PLLST_SHIFT   (5U)
 
#define MCG_S_PLLST(x)   (((uint8_t)(((uint8_t)(x)) << MCG_S_PLLST_SHIFT)) & MCG_S_PLLST_MASK)
 
#define MCG_S_LOCK0_MASK   (0x40U)
 
#define MCG_S_LOCK0_SHIFT   (6U)
 
#define MCG_S_LOCK0(x)   (((uint8_t)(((uint8_t)(x)) << MCG_S_LOCK0_SHIFT)) & MCG_S_LOCK0_MASK)
 
#define MCG_S_LOLS0_MASK   (0x80U)
 
#define MCG_S_LOLS0_SHIFT   (7U)
 
#define MCG_S_LOLS0(x)   (((uint8_t)(((uint8_t)(x)) << MCG_S_LOLS0_SHIFT)) & MCG_S_LOLS0_MASK)
 
SC - MCG Status and Control Register
#define MCG_SC_LOCS0_MASK   (0x1U)
 
#define MCG_SC_LOCS0_SHIFT   (0U)
 
#define MCG_SC_LOCS0(x)   (((uint8_t)(((uint8_t)(x)) << MCG_SC_LOCS0_SHIFT)) & MCG_SC_LOCS0_MASK)
 
#define MCG_SC_FCRDIV_MASK   (0xEU)
 
#define MCG_SC_FCRDIV_SHIFT   (1U)
 
#define MCG_SC_FCRDIV(x)   (((uint8_t)(((uint8_t)(x)) << MCG_SC_FCRDIV_SHIFT)) & MCG_SC_FCRDIV_MASK)
 
#define MCG_SC_FLTPRSRV_MASK   (0x10U)
 
#define MCG_SC_FLTPRSRV_SHIFT   (4U)
 
#define MCG_SC_FLTPRSRV(x)   (((uint8_t)(((uint8_t)(x)) << MCG_SC_FLTPRSRV_SHIFT)) & MCG_SC_FLTPRSRV_MASK)
 
#define MCG_SC_ATMF_MASK   (0x20U)
 
#define MCG_SC_ATMF_SHIFT   (5U)
 
#define MCG_SC_ATMF(x)   (((uint8_t)(((uint8_t)(x)) << MCG_SC_ATMF_SHIFT)) & MCG_SC_ATMF_MASK)
 
#define MCG_SC_ATMS_MASK   (0x40U)
 
#define MCG_SC_ATMS_SHIFT   (6U)
 
#define MCG_SC_ATMS(x)   (((uint8_t)(((uint8_t)(x)) << MCG_SC_ATMS_SHIFT)) & MCG_SC_ATMS_MASK)
 
#define MCG_SC_ATME_MASK   (0x80U)
 
#define MCG_SC_ATME_SHIFT   (7U)
 
#define MCG_SC_ATME(x)   (((uint8_t)(((uint8_t)(x)) << MCG_SC_ATME_SHIFT)) & MCG_SC_ATME_MASK)
 
ATCVH - MCG Auto Trim Compare Value High Register
#define MCG_ATCVH_ATCVH_MASK   (0xFFU)
 
#define MCG_ATCVH_ATCVH_SHIFT   (0U)
 
#define MCG_ATCVH_ATCVH(x)   (((uint8_t)(((uint8_t)(x)) << MCG_ATCVH_ATCVH_SHIFT)) & MCG_ATCVH_ATCVH_MASK)
 
ATCVL - MCG Auto Trim Compare Value Low Register
#define MCG_ATCVL_ATCVL_MASK   (0xFFU)
 
#define MCG_ATCVL_ATCVL_SHIFT   (0U)
 
#define MCG_ATCVL_ATCVL(x)   (((uint8_t)(((uint8_t)(x)) << MCG_ATCVL_ATCVL_SHIFT)) & MCG_ATCVL_ATCVL_MASK)
 
C7 - MCG Control 7 Register
#define MCG_C7_OSCSEL_MASK   (0x3U)
 
#define MCG_C7_OSCSEL_SHIFT   (0U)
 
#define MCG_C7_OSCSEL(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C7_OSCSEL_SHIFT)) & MCG_C7_OSCSEL_MASK)
 
C8 - MCG Control 8 Register
#define MCG_C8_LOCS1_MASK   (0x1U)
 
#define MCG_C8_LOCS1_SHIFT   (0U)
 
#define MCG_C8_LOCS1(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C8_LOCS1_SHIFT)) & MCG_C8_LOCS1_MASK)
 
#define MCG_C8_CME1_MASK   (0x20U)
 
#define MCG_C8_CME1_SHIFT   (5U)
 
#define MCG_C8_CME1(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C8_CME1_SHIFT)) & MCG_C8_CME1_MASK)
 
#define MCG_C8_LOLRE_MASK   (0x40U)
 
#define MCG_C8_LOLRE_SHIFT   (6U)
 
#define MCG_C8_LOLRE(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C8_LOLRE_SHIFT)) & MCG_C8_LOLRE_MASK)
 
#define MCG_C8_LOCRE1_MASK   (0x80U)
 
#define MCG_C8_LOCRE1_SHIFT   (7U)
 
#define MCG_C8_LOCRE1(x)   (((uint8_t)(((uint8_t)(x)) << MCG_C8_LOCRE1_SHIFT)) & MCG_C8_LOCRE1_MASK)
 
PLASC - Crossbar Switch (AXBS) Slave Configuration
#define MCM_PLASC_ASC_MASK   (0xFFU)
 
#define MCM_PLASC_ASC_SHIFT   (0U)
 
#define MCM_PLASC_ASC(x)   (((uint16_t)(((uint16_t)(x)) << MCM_PLASC_ASC_SHIFT)) & MCM_PLASC_ASC_MASK)
 
PLAMC - Crossbar Switch (AXBS) Master Configuration
#define MCM_PLAMC_AMC_MASK   (0xFFU)
 
#define MCM_PLAMC_AMC_SHIFT   (0U)
 
#define MCM_PLAMC_AMC(x)   (((uint16_t)(((uint16_t)(x)) << MCM_PLAMC_AMC_SHIFT)) & MCM_PLAMC_AMC_MASK)
 
ISCR - Interrupt Status Register
#define MCM_ISCR_IRQ_MASK   (0x2U)
 
#define MCM_ISCR_IRQ_SHIFT   (1U)
 
#define MCM_ISCR_IRQ(x)   (((uint32_t)(((uint32_t)(x)) << MCM_ISCR_IRQ_SHIFT)) & MCM_ISCR_IRQ_MASK)
 
#define MCM_ISCR_NMI_MASK   (0x4U)
 
#define MCM_ISCR_NMI_SHIFT   (2U)
 
#define MCM_ISCR_NMI(x)   (((uint32_t)(((uint32_t)(x)) << MCM_ISCR_NMI_SHIFT)) & MCM_ISCR_NMI_MASK)
 
#define MCM_ISCR_DHREQ_MASK   (0x8U)
 
#define MCM_ISCR_DHREQ_SHIFT   (3U)
 
#define MCM_ISCR_DHREQ(x)   (((uint32_t)(((uint32_t)(x)) << MCM_ISCR_DHREQ_SHIFT)) & MCM_ISCR_DHREQ_MASK)
 
#define MCM_ISCR_FIOC_MASK   (0x100U)
 
#define MCM_ISCR_FIOC_SHIFT   (8U)
 
#define MCM_ISCR_FIOC(x)   (((uint32_t)(((uint32_t)(x)) << MCM_ISCR_FIOC_SHIFT)) & MCM_ISCR_FIOC_MASK)
 
#define MCM_ISCR_FDZC_MASK   (0x200U)
 
#define MCM_ISCR_FDZC_SHIFT   (9U)
 
#define MCM_ISCR_FDZC(x)   (((uint32_t)(((uint32_t)(x)) << MCM_ISCR_FDZC_SHIFT)) & MCM_ISCR_FDZC_MASK)
 
#define MCM_ISCR_FOFC_MASK   (0x400U)
 
#define MCM_ISCR_FOFC_SHIFT   (10U)
 
#define MCM_ISCR_FOFC(x)   (((uint32_t)(((uint32_t)(x)) << MCM_ISCR_FOFC_SHIFT)) & MCM_ISCR_FOFC_MASK)
 
#define MCM_ISCR_FUFC_MASK   (0x800U)
 
#define MCM_ISCR_FUFC_SHIFT   (11U)
 
#define MCM_ISCR_FUFC(x)   (((uint32_t)(((uint32_t)(x)) << MCM_ISCR_FUFC_SHIFT)) & MCM_ISCR_FUFC_MASK)
 
#define MCM_ISCR_FIXC_MASK   (0x1000U)
 
#define MCM_ISCR_FIXC_SHIFT   (12U)
 
#define MCM_ISCR_FIXC(x)   (((uint32_t)(((uint32_t)(x)) << MCM_ISCR_FIXC_SHIFT)) & MCM_ISCR_FIXC_MASK)
 
#define MCM_ISCR_FIDC_MASK   (0x8000U)
 
#define MCM_ISCR_FIDC_SHIFT   (15U)
 
#define MCM_ISCR_FIDC(x)   (((uint32_t)(((uint32_t)(x)) << MCM_ISCR_FIDC_SHIFT)) & MCM_ISCR_FIDC_MASK)
 
#define MCM_ISCR_FIOCE_MASK   (0x1000000U)
 
#define MCM_ISCR_FIOCE_SHIFT   (24U)
 
#define MCM_ISCR_FIOCE(x)   (((uint32_t)(((uint32_t)(x)) << MCM_ISCR_FIOCE_SHIFT)) & MCM_ISCR_FIOCE_MASK)
 
#define MCM_ISCR_FDZCE_MASK   (0x2000000U)
 
#define MCM_ISCR_FDZCE_SHIFT   (25U)
 
#define MCM_ISCR_FDZCE(x)   (((uint32_t)(((uint32_t)(x)) << MCM_ISCR_FDZCE_SHIFT)) & MCM_ISCR_FDZCE_MASK)
 
#define MCM_ISCR_FOFCE_MASK   (0x4000000U)
 
#define MCM_ISCR_FOFCE_SHIFT   (26U)
 
#define MCM_ISCR_FOFCE(x)   (((uint32_t)(((uint32_t)(x)) << MCM_ISCR_FOFCE_SHIFT)) & MCM_ISCR_FOFCE_MASK)
 
#define MCM_ISCR_FUFCE_MASK   (0x8000000U)
 
#define MCM_ISCR_FUFCE_SHIFT   (27U)
 
#define MCM_ISCR_FUFCE(x)   (((uint32_t)(((uint32_t)(x)) << MCM_ISCR_FUFCE_SHIFT)) & MCM_ISCR_FUFCE_MASK)
 
#define MCM_ISCR_FIXCE_MASK   (0x10000000U)
 
#define MCM_ISCR_FIXCE_SHIFT   (28U)
 
#define MCM_ISCR_FIXCE(x)   (((uint32_t)(((uint32_t)(x)) << MCM_ISCR_FIXCE_SHIFT)) & MCM_ISCR_FIXCE_MASK)
 
#define MCM_ISCR_FIDCE_MASK   (0x80000000U)
 
#define MCM_ISCR_FIDCE_SHIFT   (31U)
 
#define MCM_ISCR_FIDCE(x)   (((uint32_t)(((uint32_t)(x)) << MCM_ISCR_FIDCE_SHIFT)) & MCM_ISCR_FIDCE_MASK)
 
ETBCC - ETB Counter Control register
#define MCM_ETBCC_CNTEN_MASK   (0x1U)
 
#define MCM_ETBCC_CNTEN_SHIFT   (0U)
 
#define MCM_ETBCC_CNTEN(x)   (((uint32_t)(((uint32_t)(x)) << MCM_ETBCC_CNTEN_SHIFT)) & MCM_ETBCC_CNTEN_MASK)
 
#define MCM_ETBCC_RSPT_MASK   (0x6U)
 
#define MCM_ETBCC_RSPT_SHIFT   (1U)
 
#define MCM_ETBCC_RSPT(x)   (((uint32_t)(((uint32_t)(x)) << MCM_ETBCC_RSPT_SHIFT)) & MCM_ETBCC_RSPT_MASK)
 
#define MCM_ETBCC_RLRQ_MASK   (0x8U)
 
#define MCM_ETBCC_RLRQ_SHIFT   (3U)
 
#define MCM_ETBCC_RLRQ(x)   (((uint32_t)(((uint32_t)(x)) << MCM_ETBCC_RLRQ_SHIFT)) & MCM_ETBCC_RLRQ_MASK)
 
#define MCM_ETBCC_ETDIS_MASK   (0x10U)
 
#define MCM_ETBCC_ETDIS_SHIFT   (4U)
 
#define MCM_ETBCC_ETDIS(x)   (((uint32_t)(((uint32_t)(x)) << MCM_ETBCC_ETDIS_SHIFT)) & MCM_ETBCC_ETDIS_MASK)
 
#define MCM_ETBCC_ITDIS_MASK   (0x20U)
 
#define MCM_ETBCC_ITDIS_SHIFT   (5U)
 
#define MCM_ETBCC_ITDIS(x)   (((uint32_t)(((uint32_t)(x)) << MCM_ETBCC_ITDIS_SHIFT)) & MCM_ETBCC_ITDIS_MASK)
 
ETBRL - ETB Reload register
#define MCM_ETBRL_RELOAD_MASK   (0x7FFU)
 
#define MCM_ETBRL_RELOAD_SHIFT   (0U)
 
#define MCM_ETBRL_RELOAD(x)   (((uint32_t)(((uint32_t)(x)) << MCM_ETBRL_RELOAD_SHIFT)) & MCM_ETBRL_RELOAD_MASK)
 
ETBCNT - ETB Counter Value register
#define MCM_ETBCNT_COUNTER_MASK   (0x7FFU)
 
#define MCM_ETBCNT_COUNTER_SHIFT   (0U)
 
#define MCM_ETBCNT_COUNTER(x)   (((uint32_t)(((uint32_t)(x)) << MCM_ETBCNT_COUNTER_SHIFT)) & MCM_ETBCNT_COUNTER_MASK)
 
PID - Process ID register
#define MCM_PID_PID_MASK   (0xFFU)
 
#define MCM_PID_PID_SHIFT   (0U)
 
#define MCM_PID_PID(x)   (((uint32_t)(((uint32_t)(x)) << MCM_PID_PID_SHIFT)) & MCM_PID_PID_MASK)
 
BACKKEY3 - Backdoor Comparison Key 3.
#define NV_BACKKEY3_KEY_MASK   (0xFFU)
 
#define NV_BACKKEY3_KEY_SHIFT   (0U)
 
#define NV_BACKKEY3_KEY(x)   (((uint8_t)(((uint8_t)(x)) << NV_BACKKEY3_KEY_SHIFT)) & NV_BACKKEY3_KEY_MASK)
 
BACKKEY2 - Backdoor Comparison Key 2.
#define NV_BACKKEY2_KEY_MASK   (0xFFU)
 
#define NV_BACKKEY2_KEY_SHIFT   (0U)
 
#define NV_BACKKEY2_KEY(x)   (((uint8_t)(((uint8_t)(x)) << NV_BACKKEY2_KEY_SHIFT)) & NV_BACKKEY2_KEY_MASK)
 
BACKKEY1 - Backdoor Comparison Key 1.
#define NV_BACKKEY1_KEY_MASK   (0xFFU)
 
#define NV_BACKKEY1_KEY_SHIFT   (0U)
 
#define NV_BACKKEY1_KEY(x)   (((uint8_t)(((uint8_t)(x)) << NV_BACKKEY1_KEY_SHIFT)) & NV_BACKKEY1_KEY_MASK)
 
BACKKEY0 - Backdoor Comparison Key 0.
#define NV_BACKKEY0_KEY_MASK   (0xFFU)
 
#define NV_BACKKEY0_KEY_SHIFT   (0U)
 
#define NV_BACKKEY0_KEY(x)   (((uint8_t)(((uint8_t)(x)) << NV_BACKKEY0_KEY_SHIFT)) & NV_BACKKEY0_KEY_MASK)
 
BACKKEY7 - Backdoor Comparison Key 7.
#define NV_BACKKEY7_KEY_MASK   (0xFFU)
 
#define NV_BACKKEY7_KEY_SHIFT   (0U)
 
#define NV_BACKKEY7_KEY(x)   (((uint8_t)(((uint8_t)(x)) << NV_BACKKEY7_KEY_SHIFT)) & NV_BACKKEY7_KEY_MASK)
 
BACKKEY6 - Backdoor Comparison Key 6.
#define NV_BACKKEY6_KEY_MASK   (0xFFU)
 
#define NV_BACKKEY6_KEY_SHIFT   (0U)
 
#define NV_BACKKEY6_KEY(x)   (((uint8_t)(((uint8_t)(x)) << NV_BACKKEY6_KEY_SHIFT)) & NV_BACKKEY6_KEY_MASK)
 
BACKKEY5 - Backdoor Comparison Key 5.
#define NV_BACKKEY5_KEY_MASK   (0xFFU)
 
#define NV_BACKKEY5_KEY_SHIFT   (0U)
 
#define NV_BACKKEY5_KEY(x)   (((uint8_t)(((uint8_t)(x)) << NV_BACKKEY5_KEY_SHIFT)) & NV_BACKKEY5_KEY_MASK)
 
BACKKEY4 - Backdoor Comparison Key 4.
#define NV_BACKKEY4_KEY_MASK   (0xFFU)
 
#define NV_BACKKEY4_KEY_SHIFT   (0U)
 
#define NV_BACKKEY4_KEY(x)   (((uint8_t)(((uint8_t)(x)) << NV_BACKKEY4_KEY_SHIFT)) & NV_BACKKEY4_KEY_MASK)
 
FPROT3 - Non-volatile P-Flash Protection 1 - Low Register
#define NV_FPROT3_PROT_MASK   (0xFFU)
 
#define NV_FPROT3_PROT_SHIFT   (0U)
 
#define NV_FPROT3_PROT(x)   (((uint8_t)(((uint8_t)(x)) << NV_FPROT3_PROT_SHIFT)) & NV_FPROT3_PROT_MASK)
 
FPROT2 - Non-volatile P-Flash Protection 1 - High Register
#define NV_FPROT2_PROT_MASK   (0xFFU)
 
#define NV_FPROT2_PROT_SHIFT   (0U)
 
#define NV_FPROT2_PROT(x)   (((uint8_t)(((uint8_t)(x)) << NV_FPROT2_PROT_SHIFT)) & NV_FPROT2_PROT_MASK)
 
FPROT1 - Non-volatile P-Flash Protection 0 - Low Register
#define NV_FPROT1_PROT_MASK   (0xFFU)
 
#define NV_FPROT1_PROT_SHIFT   (0U)
 
#define NV_FPROT1_PROT(x)   (((uint8_t)(((uint8_t)(x)) << NV_FPROT1_PROT_SHIFT)) & NV_FPROT1_PROT_MASK)
 
FPROT0 - Non-volatile P-Flash Protection 0 - High Register
#define NV_FPROT0_PROT_MASK   (0xFFU)
 
#define NV_FPROT0_PROT_SHIFT   (0U)
 
#define NV_FPROT0_PROT(x)   (((uint8_t)(((uint8_t)(x)) << NV_FPROT0_PROT_SHIFT)) & NV_FPROT0_PROT_MASK)
 
FSEC - Non-volatile Flash Security Register
#define NV_FSEC_SEC_MASK   (0x3U)
 
#define NV_FSEC_SEC_SHIFT   (0U)
 
#define NV_FSEC_SEC(x)   (((uint8_t)(((uint8_t)(x)) << NV_FSEC_SEC_SHIFT)) & NV_FSEC_SEC_MASK)
 
#define NV_FSEC_FSLACC_MASK   (0xCU)
 
#define NV_FSEC_FSLACC_SHIFT   (2U)
 
#define NV_FSEC_FSLACC(x)   (((uint8_t)(((uint8_t)(x)) << NV_FSEC_FSLACC_SHIFT)) & NV_FSEC_FSLACC_MASK)
 
#define NV_FSEC_MEEN_MASK   (0x30U)
 
#define NV_FSEC_MEEN_SHIFT   (4U)
 
#define NV_FSEC_MEEN(x)   (((uint8_t)(((uint8_t)(x)) << NV_FSEC_MEEN_SHIFT)) & NV_FSEC_MEEN_MASK)
 
#define NV_FSEC_KEYEN_MASK   (0xC0U)
 
#define NV_FSEC_KEYEN_SHIFT   (6U)
 
#define NV_FSEC_KEYEN(x)   (((uint8_t)(((uint8_t)(x)) << NV_FSEC_KEYEN_SHIFT)) & NV_FSEC_KEYEN_MASK)
 
FOPT - Non-volatile Flash Option Register
#define NV_FOPT_LPBOOT_MASK   (0x1U)
 
#define NV_FOPT_LPBOOT_SHIFT   (0U)
 
#define NV_FOPT_LPBOOT(x)   (((uint8_t)(((uint8_t)(x)) << NV_FOPT_LPBOOT_SHIFT)) & NV_FOPT_LPBOOT_MASK)
 
#define NV_FOPT_EZPORT_DIS_MASK   (0x2U)
 
#define NV_FOPT_EZPORT_DIS_SHIFT   (1U)
 
#define NV_FOPT_EZPORT_DIS(x)   (((uint8_t)(((uint8_t)(x)) << NV_FOPT_EZPORT_DIS_SHIFT)) & NV_FOPT_EZPORT_DIS_MASK)
 
FEPROT - Non-volatile EERAM Protection Register
#define NV_FEPROT_EPROT_MASK   (0xFFU)
 
#define NV_FEPROT_EPROT_SHIFT   (0U)
 
#define NV_FEPROT_EPROT(x)   (((uint8_t)(((uint8_t)(x)) << NV_FEPROT_EPROT_SHIFT)) & NV_FEPROT_EPROT_MASK)
 
FDPROT - Non-volatile D-Flash Protection Register
#define NV_FDPROT_DPROT_MASK   (0xFFU)
 
#define NV_FDPROT_DPROT_SHIFT   (0U)
 
#define NV_FDPROT_DPROT(x)   (((uint8_t)(((uint8_t)(x)) << NV_FDPROT_DPROT_SHIFT)) & NV_FDPROT_DPROT_MASK)
 
CR - OSC Control Register
#define OSC_CR_SC16P_MASK   (0x1U)
 
#define OSC_CR_SC16P_SHIFT   (0U)
 
#define OSC_CR_SC16P(x)   (((uint8_t)(((uint8_t)(x)) << OSC_CR_SC16P_SHIFT)) & OSC_CR_SC16P_MASK)
 
#define OSC_CR_SC8P_MASK   (0x2U)
 
#define OSC_CR_SC8P_SHIFT   (1U)
 
#define OSC_CR_SC8P(x)   (((uint8_t)(((uint8_t)(x)) << OSC_CR_SC8P_SHIFT)) & OSC_CR_SC8P_MASK)
 
#define OSC_CR_SC4P_MASK   (0x4U)
 
#define OSC_CR_SC4P_SHIFT   (2U)
 
#define OSC_CR_SC4P(x)   (((uint8_t)(((uint8_t)(x)) << OSC_CR_SC4P_SHIFT)) & OSC_CR_SC4P_MASK)
 
#define OSC_CR_SC2P_MASK   (0x8U)
 
#define OSC_CR_SC2P_SHIFT   (3U)
 
#define OSC_CR_SC2P(x)   (((uint8_t)(((uint8_t)(x)) << OSC_CR_SC2P_SHIFT)) & OSC_CR_SC2P_MASK)
 
#define OSC_CR_EREFSTEN_MASK   (0x20U)
 
#define OSC_CR_EREFSTEN_SHIFT   (5U)
 
#define OSC_CR_EREFSTEN(x)   (((uint8_t)(((uint8_t)(x)) << OSC_CR_EREFSTEN_SHIFT)) & OSC_CR_EREFSTEN_MASK)
 
#define OSC_CR_ERCLKEN_MASK   (0x80U)
 
#define OSC_CR_ERCLKEN_SHIFT   (7U)
 
#define OSC_CR_ERCLKEN(x)   (((uint8_t)(((uint8_t)(x)) << OSC_CR_ERCLKEN_SHIFT)) & OSC_CR_ERCLKEN_MASK)
 
SC - Status and Control register
#define PDB_SC_LDOK_MASK   (0x1U)
 
#define PDB_SC_LDOK_SHIFT   (0U)
 
#define PDB_SC_LDOK(x)   (((uint32_t)(((uint32_t)(x)) << PDB_SC_LDOK_SHIFT)) & PDB_SC_LDOK_MASK)
 
#define PDB_SC_CONT_MASK   (0x2U)
 
#define PDB_SC_CONT_SHIFT   (1U)
 
#define PDB_SC_CONT(x)   (((uint32_t)(((uint32_t)(x)) << PDB_SC_CONT_SHIFT)) & PDB_SC_CONT_MASK)
 
#define PDB_SC_MULT_MASK   (0xCU)
 
#define PDB_SC_MULT_SHIFT   (2U)
 
#define PDB_SC_MULT(x)   (((uint32_t)(((uint32_t)(x)) << PDB_SC_MULT_SHIFT)) & PDB_SC_MULT_MASK)
 
#define PDB_SC_PDBIE_MASK   (0x20U)
 
#define PDB_SC_PDBIE_SHIFT   (5U)
 
#define PDB_SC_PDBIE(x)   (((uint32_t)(((uint32_t)(x)) << PDB_SC_PDBIE_SHIFT)) & PDB_SC_PDBIE_MASK)
 
#define PDB_SC_PDBIF_MASK   (0x40U)
 
#define PDB_SC_PDBIF_SHIFT   (6U)
 
#define PDB_SC_PDBIF(x)   (((uint32_t)(((uint32_t)(x)) << PDB_SC_PDBIF_SHIFT)) & PDB_SC_PDBIF_MASK)
 
#define PDB_SC_PDBEN_MASK   (0x80U)
 
#define PDB_SC_PDBEN_SHIFT   (7U)
 
#define PDB_SC_PDBEN(x)   (((uint32_t)(((uint32_t)(x)) << PDB_SC_PDBEN_SHIFT)) & PDB_SC_PDBEN_MASK)
 
#define PDB_SC_TRGSEL_MASK   (0xF00U)
 
#define PDB_SC_TRGSEL_SHIFT   (8U)
 
#define PDB_SC_TRGSEL(x)   (((uint32_t)(((uint32_t)(x)) << PDB_SC_TRGSEL_SHIFT)) & PDB_SC_TRGSEL_MASK)
 
#define PDB_SC_PRESCALER_MASK   (0x7000U)
 
#define PDB_SC_PRESCALER_SHIFT   (12U)
 
#define PDB_SC_PRESCALER(x)   (((uint32_t)(((uint32_t)(x)) << PDB_SC_PRESCALER_SHIFT)) & PDB_SC_PRESCALER_MASK)
 
#define PDB_SC_DMAEN_MASK   (0x8000U)
 
#define PDB_SC_DMAEN_SHIFT   (15U)
 
#define PDB_SC_DMAEN(x)   (((uint32_t)(((uint32_t)(x)) << PDB_SC_DMAEN_SHIFT)) & PDB_SC_DMAEN_MASK)
 
#define PDB_SC_SWTRIG_MASK   (0x10000U)
 
#define PDB_SC_SWTRIG_SHIFT   (16U)
 
#define PDB_SC_SWTRIG(x)   (((uint32_t)(((uint32_t)(x)) << PDB_SC_SWTRIG_SHIFT)) & PDB_SC_SWTRIG_MASK)
 
#define PDB_SC_PDBEIE_MASK   (0x20000U)
 
#define PDB_SC_PDBEIE_SHIFT   (17U)
 
#define PDB_SC_PDBEIE(x)   (((uint32_t)(((uint32_t)(x)) << PDB_SC_PDBEIE_SHIFT)) & PDB_SC_PDBEIE_MASK)
 
#define PDB_SC_LDMOD_MASK   (0xC0000U)
 
#define PDB_SC_LDMOD_SHIFT   (18U)
 
#define PDB_SC_LDMOD(x)   (((uint32_t)(((uint32_t)(x)) << PDB_SC_LDMOD_SHIFT)) & PDB_SC_LDMOD_MASK)
 
MOD - Modulus register
#define PDB_MOD_MOD_MASK   (0xFFFFU)
 
#define PDB_MOD_MOD_SHIFT   (0U)
 
#define PDB_MOD_MOD(x)   (((uint32_t)(((uint32_t)(x)) << PDB_MOD_MOD_SHIFT)) & PDB_MOD_MOD_MASK)
 
CNT - Counter register
#define PDB_CNT_CNT_MASK   (0xFFFFU)
 
#define PDB_CNT_CNT_SHIFT   (0U)
 
#define PDB_CNT_CNT(x)   (((uint32_t)(((uint32_t)(x)) << PDB_CNT_CNT_SHIFT)) & PDB_CNT_CNT_MASK)
 
IDLY - Interrupt Delay register
#define PDB_IDLY_IDLY_MASK   (0xFFFFU)
 
#define PDB_IDLY_IDLY_SHIFT   (0U)
 
#define PDB_IDLY_IDLY(x)   (((uint32_t)(((uint32_t)(x)) << PDB_IDLY_IDLY_SHIFT)) & PDB_IDLY_IDLY_MASK)
 
C1 - Channel n Control register 1
#define PDB_C1_EN_MASK   (0xFFU)
 
#define PDB_C1_EN_SHIFT   (0U)
 
#define PDB_C1_EN(x)   (((uint32_t)(((uint32_t)(x)) << PDB_C1_EN_SHIFT)) & PDB_C1_EN_MASK)
 
#define PDB_C1_TOS_MASK   (0xFF00U)
 
#define PDB_C1_TOS_SHIFT   (8U)
 
#define PDB_C1_TOS(x)   (((uint32_t)(((uint32_t)(x)) << PDB_C1_TOS_SHIFT)) & PDB_C1_TOS_MASK)
 
#define PDB_C1_BB_MASK   (0xFF0000U)
 
#define PDB_C1_BB_SHIFT   (16U)
 
#define PDB_C1_BB(x)   (((uint32_t)(((uint32_t)(x)) << PDB_C1_BB_SHIFT)) & PDB_C1_BB_MASK)
 
#define PDB_C1_COUNT   (2U)
 
S - Channel n Status register
#define PDB_S_ERR_MASK   (0xFFU)
 
#define PDB_S_ERR_SHIFT   (0U)
 
#define PDB_S_ERR(x)   (((uint32_t)(((uint32_t)(x)) << PDB_S_ERR_SHIFT)) & PDB_S_ERR_MASK)
 
#define PDB_S_CF_MASK   (0xFF0000U)
 
#define PDB_S_CF_SHIFT   (16U)
 
#define PDB_S_CF(x)   (((uint32_t)(((uint32_t)(x)) << PDB_S_CF_SHIFT)) & PDB_S_CF_MASK)
 
#define PDB_S_COUNT   (2U)
 
DLY - Channel n Delay 0 register..Channel n Delay 1 register
#define PDB_DLY_DLY_MASK   (0xFFFFU)
 
#define PDB_DLY_DLY_SHIFT   (0U)
 
#define PDB_DLY_DLY(x)   (((uint32_t)(((uint32_t)(x)) << PDB_DLY_DLY_SHIFT)) & PDB_DLY_DLY_MASK)
 
#define PDB_DLY_COUNT   (2U)
 
#define PDB_DLY_COUNT2   (2U)
 
INTC - DAC Interval Trigger n Control register
#define PDB_INTC_TOE_MASK   (0x1U)
 
#define PDB_INTC_TOE_SHIFT   (0U)
 
#define PDB_INTC_TOE(x)   (((uint32_t)(((uint32_t)(x)) << PDB_INTC_TOE_SHIFT)) & PDB_INTC_TOE_MASK)
 
#define PDB_INTC_EXT_MASK   (0x2U)
 
#define PDB_INTC_EXT_SHIFT   (1U)
 
#define PDB_INTC_EXT(x)   (((uint32_t)(((uint32_t)(x)) << PDB_INTC_EXT_SHIFT)) & PDB_INTC_EXT_MASK)
 
#define PDB_INTC_COUNT   (2U)
 
INT - DAC Interval n register
#define PDB_INT_INT_MASK   (0xFFFFU)
 
#define PDB_INT_INT_SHIFT   (0U)
 
#define PDB_INT_INT(x)   (((uint32_t)(((uint32_t)(x)) << PDB_INT_INT_SHIFT)) & PDB_INT_INT_MASK)
 
#define PDB_INT_COUNT   (2U)
 
POEN - Pulse-Out n Enable register
#define PDB_POEN_POEN_MASK   (0xFFU)
 
#define PDB_POEN_POEN_SHIFT   (0U)
 
#define PDB_POEN_POEN(x)   (((uint32_t)(((uint32_t)(x)) << PDB_POEN_POEN_SHIFT)) & PDB_POEN_POEN_MASK)
 
PODLY - Pulse-Out n Delay register
#define PDB_PODLY_DLY2_MASK   (0xFFFFU)
 
#define PDB_PODLY_DLY2_SHIFT   (0U)
 
#define PDB_PODLY_DLY2(x)   (((uint32_t)(((uint32_t)(x)) << PDB_PODLY_DLY2_SHIFT)) & PDB_PODLY_DLY2_MASK)
 
#define PDB_PODLY_DLY1_MASK   (0xFFFF0000U)
 
#define PDB_PODLY_DLY1_SHIFT   (16U)
 
#define PDB_PODLY_DLY1(x)   (((uint32_t)(((uint32_t)(x)) << PDB_PODLY_DLY1_SHIFT)) & PDB_PODLY_DLY1_MASK)
 
#define PDB_PODLY_COUNT   (3U)
 
MCR - PIT Module Control Register
#define PIT_MCR_FRZ_MASK   (0x1U)
 
#define PIT_MCR_FRZ_SHIFT   (0U)
 
#define PIT_MCR_FRZ(x)   (((uint32_t)(((uint32_t)(x)) << PIT_MCR_FRZ_SHIFT)) & PIT_MCR_FRZ_MASK)
 
#define PIT_MCR_MDIS_MASK   (0x2U)
 
#define PIT_MCR_MDIS_SHIFT   (1U)
 
#define PIT_MCR_MDIS(x)   (((uint32_t)(((uint32_t)(x)) << PIT_MCR_MDIS_SHIFT)) & PIT_MCR_MDIS_MASK)
 
LDVAL - Timer Load Value Register
#define PIT_LDVAL_TSV_MASK   (0xFFFFFFFFU)
 
#define PIT_LDVAL_TSV_SHIFT   (0U)
 
#define PIT_LDVAL_TSV(x)   (((uint32_t)(((uint32_t)(x)) << PIT_LDVAL_TSV_SHIFT)) & PIT_LDVAL_TSV_MASK)
 
#define PIT_LDVAL_COUNT   (4U)
 
CVAL - Current Timer Value Register
#define PIT_CVAL_TVL_MASK   (0xFFFFFFFFU)
 
#define PIT_CVAL_TVL_SHIFT   (0U)
 
#define PIT_CVAL_TVL(x)   (((uint32_t)(((uint32_t)(x)) << PIT_CVAL_TVL_SHIFT)) & PIT_CVAL_TVL_MASK)
 
#define PIT_CVAL_COUNT   (4U)
 
TCTRL - Timer Control Register
#define PIT_TCTRL_TEN_MASK   (0x1U)
 
#define PIT_TCTRL_TEN_SHIFT   (0U)
 
#define PIT_TCTRL_TEN(x)   (((uint32_t)(((uint32_t)(x)) << PIT_TCTRL_TEN_SHIFT)) & PIT_TCTRL_TEN_MASK)
 
#define PIT_TCTRL_TIE_MASK   (0x2U)
 
#define PIT_TCTRL_TIE_SHIFT   (1U)
 
#define PIT_TCTRL_TIE(x)   (((uint32_t)(((uint32_t)(x)) << PIT_TCTRL_TIE_SHIFT)) & PIT_TCTRL_TIE_MASK)
 
#define PIT_TCTRL_CHN_MASK   (0x4U)
 
#define PIT_TCTRL_CHN_SHIFT   (2U)
 
#define PIT_TCTRL_CHN(x)   (((uint32_t)(((uint32_t)(x)) << PIT_TCTRL_CHN_SHIFT)) & PIT_TCTRL_CHN_MASK)
 
#define PIT_TCTRL_COUNT   (4U)
 
TFLG - Timer Flag Register
#define PIT_TFLG_TIF_MASK   (0x1U)
 
#define PIT_TFLG_TIF_SHIFT   (0U)
 
#define PIT_TFLG_TIF(x)   (((uint32_t)(((uint32_t)(x)) << PIT_TFLG_TIF_SHIFT)) & PIT_TFLG_TIF_MASK)
 
#define PIT_TFLG_COUNT   (4U)
 
LVDSC1 - Low Voltage Detect Status And Control 1 register
#define PMC_LVDSC1_LVDV_MASK   (0x3U)
 
#define PMC_LVDSC1_LVDV_SHIFT   (0U)
 
#define PMC_LVDSC1_LVDV(x)   (((uint8_t)(((uint8_t)(x)) << PMC_LVDSC1_LVDV_SHIFT)) & PMC_LVDSC1_LVDV_MASK)
 
#define PMC_LVDSC1_LVDRE_MASK   (0x10U)
 
#define PMC_LVDSC1_LVDRE_SHIFT   (4U)
 
#define PMC_LVDSC1_LVDRE(x)   (((uint8_t)(((uint8_t)(x)) << PMC_LVDSC1_LVDRE_SHIFT)) & PMC_LVDSC1_LVDRE_MASK)
 
#define PMC_LVDSC1_LVDIE_MASK   (0x20U)
 
#define PMC_LVDSC1_LVDIE_SHIFT   (5U)
 
#define PMC_LVDSC1_LVDIE(x)   (((uint8_t)(((uint8_t)(x)) << PMC_LVDSC1_LVDIE_SHIFT)) & PMC_LVDSC1_LVDIE_MASK)
 
#define PMC_LVDSC1_LVDACK_MASK   (0x40U)
 
#define PMC_LVDSC1_LVDACK_SHIFT   (6U)
 
#define PMC_LVDSC1_LVDACK(x)   (((uint8_t)(((uint8_t)(x)) << PMC_LVDSC1_LVDACK_SHIFT)) & PMC_LVDSC1_LVDACK_MASK)
 
#define PMC_LVDSC1_LVDF_MASK   (0x80U)
 
#define PMC_LVDSC1_LVDF_SHIFT   (7U)
 
#define PMC_LVDSC1_LVDF(x)   (((uint8_t)(((uint8_t)(x)) << PMC_LVDSC1_LVDF_SHIFT)) & PMC_LVDSC1_LVDF_MASK)
 
LVDSC2 - Low Voltage Detect Status And Control 2 register
#define PMC_LVDSC2_LVWV_MASK   (0x3U)
 
#define PMC_LVDSC2_LVWV_SHIFT   (0U)
 
#define PMC_LVDSC2_LVWV(x)   (((uint8_t)(((uint8_t)(x)) << PMC_LVDSC2_LVWV_SHIFT)) & PMC_LVDSC2_LVWV_MASK)
 
#define PMC_LVDSC2_LVWIE_MASK   (0x20U)
 
#define PMC_LVDSC2_LVWIE_SHIFT   (5U)
 
#define PMC_LVDSC2_LVWIE(x)   (((uint8_t)(((uint8_t)(x)) << PMC_LVDSC2_LVWIE_SHIFT)) & PMC_LVDSC2_LVWIE_MASK)
 
#define PMC_LVDSC2_LVWACK_MASK   (0x40U)
 
#define PMC_LVDSC2_LVWACK_SHIFT   (6U)
 
#define PMC_LVDSC2_LVWACK(x)   (((uint8_t)(((uint8_t)(x)) << PMC_LVDSC2_LVWACK_SHIFT)) & PMC_LVDSC2_LVWACK_MASK)
 
#define PMC_LVDSC2_LVWF_MASK   (0x80U)
 
#define PMC_LVDSC2_LVWF_SHIFT   (7U)
 
#define PMC_LVDSC2_LVWF(x)   (((uint8_t)(((uint8_t)(x)) << PMC_LVDSC2_LVWF_SHIFT)) & PMC_LVDSC2_LVWF_MASK)
 
REGSC - Regulator Status And Control register
#define PMC_REGSC_BGBE_MASK   (0x1U)
 
#define PMC_REGSC_BGBE_SHIFT   (0U)
 
#define PMC_REGSC_BGBE(x)   (((uint8_t)(((uint8_t)(x)) << PMC_REGSC_BGBE_SHIFT)) & PMC_REGSC_BGBE_MASK)
 
#define PMC_REGSC_REGONS_MASK   (0x4U)
 
#define PMC_REGSC_REGONS_SHIFT   (2U)
 
#define PMC_REGSC_REGONS(x)   (((uint8_t)(((uint8_t)(x)) << PMC_REGSC_REGONS_SHIFT)) & PMC_REGSC_REGONS_MASK)
 
#define PMC_REGSC_ACKISO_MASK   (0x8U)
 
#define PMC_REGSC_ACKISO_SHIFT   (3U)
 
#define PMC_REGSC_ACKISO(x)   (((uint8_t)(((uint8_t)(x)) << PMC_REGSC_ACKISO_SHIFT)) & PMC_REGSC_ACKISO_MASK)
 
#define PMC_REGSC_BGEN_MASK   (0x10U)
 
#define PMC_REGSC_BGEN_SHIFT   (4U)
 
#define PMC_REGSC_BGEN(x)   (((uint8_t)(((uint8_t)(x)) << PMC_REGSC_BGEN_SHIFT)) & PMC_REGSC_BGEN_MASK)
 
PCR - Pin Control Register n
#define PORT_PCR_PS_MASK   (0x1U)
 
#define PORT_PCR_PS_SHIFT   (0U)
 
#define PORT_PCR_PS(x)   (((uint32_t)(((uint32_t)(x)) << PORT_PCR_PS_SHIFT)) & PORT_PCR_PS_MASK)
 
#define PORT_PCR_PE_MASK   (0x2U)
 
#define PORT_PCR_PE_SHIFT   (1U)
 
#define PORT_PCR_PE(x)   (((uint32_t)(((uint32_t)(x)) << PORT_PCR_PE_SHIFT)) & PORT_PCR_PE_MASK)
 
#define PORT_PCR_SRE_MASK   (0x4U)
 
#define PORT_PCR_SRE_SHIFT   (2U)
 
#define PORT_PCR_SRE(x)   (((uint32_t)(((uint32_t)(x)) << PORT_PCR_SRE_SHIFT)) & PORT_PCR_SRE_MASK)
 
#define PORT_PCR_PFE_MASK   (0x10U)
 
#define PORT_PCR_PFE_SHIFT   (4U)
 
#define PORT_PCR_PFE(x)   (((uint32_t)(((uint32_t)(x)) << PORT_PCR_PFE_SHIFT)) & PORT_PCR_PFE_MASK)
 
#define PORT_PCR_ODE_MASK   (0x20U)
 
#define PORT_PCR_ODE_SHIFT   (5U)
 
#define PORT_PCR_ODE(x)   (((uint32_t)(((uint32_t)(x)) << PORT_PCR_ODE_SHIFT)) & PORT_PCR_ODE_MASK)
 
#define PORT_PCR_DSE_MASK   (0x40U)
 
#define PORT_PCR_DSE_SHIFT   (6U)
 
#define PORT_PCR_DSE(x)   (((uint32_t)(((uint32_t)(x)) << PORT_PCR_DSE_SHIFT)) & PORT_PCR_DSE_MASK)
 
#define PORT_PCR_MUX_MASK   (0x700U)
 
#define PORT_PCR_MUX_SHIFT   (8U)
 
#define PORT_PCR_MUX(x)   (((uint32_t)(((uint32_t)(x)) << PORT_PCR_MUX_SHIFT)) & PORT_PCR_MUX_MASK)
 
#define PORT_PCR_LK_MASK   (0x8000U)
 
#define PORT_PCR_LK_SHIFT   (15U)
 
#define PORT_PCR_LK(x)   (((uint32_t)(((uint32_t)(x)) << PORT_PCR_LK_SHIFT)) & PORT_PCR_LK_MASK)
 
#define PORT_PCR_IRQC_MASK   (0xF0000U)
 
#define PORT_PCR_IRQC_SHIFT   (16U)
 
#define PORT_PCR_IRQC(x)   (((uint32_t)(((uint32_t)(x)) << PORT_PCR_IRQC_SHIFT)) & PORT_PCR_IRQC_MASK)
 
#define PORT_PCR_ISF_MASK   (0x1000000U)
 
#define PORT_PCR_ISF_SHIFT   (24U)
 
#define PORT_PCR_ISF(x)   (((uint32_t)(((uint32_t)(x)) << PORT_PCR_ISF_SHIFT)) & PORT_PCR_ISF_MASK)
 
#define PORT_PCR_COUNT   (32U)
 
GPCLR - Global Pin Control Low Register
#define PORT_GPCLR_GPWD_MASK   (0xFFFFU)
 
#define PORT_GPCLR_GPWD_SHIFT   (0U)
 
#define PORT_GPCLR_GPWD(x)   (((uint32_t)(((uint32_t)(x)) << PORT_GPCLR_GPWD_SHIFT)) & PORT_GPCLR_GPWD_MASK)
 
#define PORT_GPCLR_GPWE_MASK   (0xFFFF0000U)
 
#define PORT_GPCLR_GPWE_SHIFT   (16U)
 
#define PORT_GPCLR_GPWE(x)   (((uint32_t)(((uint32_t)(x)) << PORT_GPCLR_GPWE_SHIFT)) & PORT_GPCLR_GPWE_MASK)
 
GPCHR - Global Pin Control High Register
#define PORT_GPCHR_GPWD_MASK   (0xFFFFU)
 
#define PORT_GPCHR_GPWD_SHIFT   (0U)
 
#define PORT_GPCHR_GPWD(x)   (((uint32_t)(((uint32_t)(x)) << PORT_GPCHR_GPWD_SHIFT)) & PORT_GPCHR_GPWD_MASK)
 
#define PORT_GPCHR_GPWE_MASK   (0xFFFF0000U)
 
#define PORT_GPCHR_GPWE_SHIFT   (16U)
 
#define PORT_GPCHR_GPWE(x)   (((uint32_t)(((uint32_t)(x)) << PORT_GPCHR_GPWE_SHIFT)) & PORT_GPCHR_GPWE_MASK)
 
ISFR - Interrupt Status Flag Register
#define PORT_ISFR_ISF_MASK   (0xFFFFFFFFU)
 
#define PORT_ISFR_ISF_SHIFT   (0U)
 
#define PORT_ISFR_ISF(x)   (((uint32_t)(((uint32_t)(x)) << PORT_ISFR_ISF_SHIFT)) & PORT_ISFR_ISF_MASK)
 
DFER - Digital Filter Enable Register
#define PORT_DFER_DFE_MASK   (0xFFFFFFFFU)
 
#define PORT_DFER_DFE_SHIFT   (0U)
 
#define PORT_DFER_DFE(x)   (((uint32_t)(((uint32_t)(x)) << PORT_DFER_DFE_SHIFT)) & PORT_DFER_DFE_MASK)
 
DFCR - Digital Filter Clock Register
#define PORT_DFCR_CS_MASK   (0x1U)
 
#define PORT_DFCR_CS_SHIFT   (0U)
 
#define PORT_DFCR_CS(x)   (((uint32_t)(((uint32_t)(x)) << PORT_DFCR_CS_SHIFT)) & PORT_DFCR_CS_MASK)
 
DFWR - Digital Filter Width Register
#define PORT_DFWR_FILT_MASK   (0x1FU)
 
#define PORT_DFWR_FILT_SHIFT   (0U)
 
#define PORT_DFWR_FILT(x)   (((uint32_t)(((uint32_t)(x)) << PORT_DFWR_FILT_SHIFT)) & PORT_DFWR_FILT_MASK)
 
SRS0 - System Reset Status Register 0
#define RCM_SRS0_WAKEUP_MASK   (0x1U)
 
#define RCM_SRS0_WAKEUP_SHIFT   (0U)
 
#define RCM_SRS0_WAKEUP(x)   (((uint8_t)(((uint8_t)(x)) << RCM_SRS0_WAKEUP_SHIFT)) & RCM_SRS0_WAKEUP_MASK)
 
#define RCM_SRS0_LVD_MASK   (0x2U)
 
#define RCM_SRS0_LVD_SHIFT   (1U)
 
#define RCM_SRS0_LVD(x)   (((uint8_t)(((uint8_t)(x)) << RCM_SRS0_LVD_SHIFT)) & RCM_SRS0_LVD_MASK)
 
#define RCM_SRS0_LOC_MASK   (0x4U)
 
#define RCM_SRS0_LOC_SHIFT   (2U)
 
#define RCM_SRS0_LOC(x)   (((uint8_t)(((uint8_t)(x)) << RCM_SRS0_LOC_SHIFT)) & RCM_SRS0_LOC_MASK)
 
#define RCM_SRS0_LOL_MASK   (0x8U)
 
#define RCM_SRS0_LOL_SHIFT   (3U)
 
#define RCM_SRS0_LOL(x)   (((uint8_t)(((uint8_t)(x)) << RCM_SRS0_LOL_SHIFT)) & RCM_SRS0_LOL_MASK)
 
#define RCM_SRS0_WDOG_MASK   (0x20U)
 
#define RCM_SRS0_WDOG_SHIFT   (5U)
 
#define RCM_SRS0_WDOG(x)   (((uint8_t)(((uint8_t)(x)) << RCM_SRS0_WDOG_SHIFT)) & RCM_SRS0_WDOG_MASK)
 
#define RCM_SRS0_PIN_MASK   (0x40U)
 
#define RCM_SRS0_PIN_SHIFT   (6U)
 
#define RCM_SRS0_PIN(x)   (((uint8_t)(((uint8_t)(x)) << RCM_SRS0_PIN_SHIFT)) & RCM_SRS0_PIN_MASK)
 
#define RCM_SRS0_POR_MASK   (0x80U)
 
#define RCM_SRS0_POR_SHIFT   (7U)
 
#define RCM_SRS0_POR(x)   (((uint8_t)(((uint8_t)(x)) << RCM_SRS0_POR_SHIFT)) & RCM_SRS0_POR_MASK)
 
SRS1 - System Reset Status Register 1
#define RCM_SRS1_JTAG_MASK   (0x1U)
 
#define RCM_SRS1_JTAG_SHIFT   (0U)
 
#define RCM_SRS1_JTAG(x)   (((uint8_t)(((uint8_t)(x)) << RCM_SRS1_JTAG_SHIFT)) & RCM_SRS1_JTAG_MASK)
 
#define RCM_SRS1_LOCKUP_MASK   (0x2U)
 
#define RCM_SRS1_LOCKUP_SHIFT   (1U)
 
#define RCM_SRS1_LOCKUP(x)   (((uint8_t)(((uint8_t)(x)) << RCM_SRS1_LOCKUP_SHIFT)) & RCM_SRS1_LOCKUP_MASK)
 
#define RCM_SRS1_SW_MASK   (0x4U)
 
#define RCM_SRS1_SW_SHIFT   (2U)
 
#define RCM_SRS1_SW(x)   (((uint8_t)(((uint8_t)(x)) << RCM_SRS1_SW_SHIFT)) & RCM_SRS1_SW_MASK)
 
#define RCM_SRS1_MDM_AP_MASK   (0x8U)
 
#define RCM_SRS1_MDM_AP_SHIFT   (3U)
 
#define RCM_SRS1_MDM_AP(x)   (((uint8_t)(((uint8_t)(x)) << RCM_SRS1_MDM_AP_SHIFT)) & RCM_SRS1_MDM_AP_MASK)
 
#define RCM_SRS1_EZPT_MASK   (0x10U)
 
#define RCM_SRS1_EZPT_SHIFT   (4U)
 
#define RCM_SRS1_EZPT(x)   (((uint8_t)(((uint8_t)(x)) << RCM_SRS1_EZPT_SHIFT)) & RCM_SRS1_EZPT_MASK)
 
#define RCM_SRS1_SACKERR_MASK   (0x20U)
 
#define RCM_SRS1_SACKERR_SHIFT   (5U)
 
#define RCM_SRS1_SACKERR(x)   (((uint8_t)(((uint8_t)(x)) << RCM_SRS1_SACKERR_SHIFT)) & RCM_SRS1_SACKERR_MASK)
 
RPFC - Reset Pin Filter Control register
#define RCM_RPFC_RSTFLTSRW_MASK   (0x3U)
 
#define RCM_RPFC_RSTFLTSRW_SHIFT   (0U)
 
#define RCM_RPFC_RSTFLTSRW(x)   (((uint8_t)(((uint8_t)(x)) << RCM_RPFC_RSTFLTSRW_SHIFT)) & RCM_RPFC_RSTFLTSRW_MASK)
 
#define RCM_RPFC_RSTFLTSS_MASK   (0x4U)
 
#define RCM_RPFC_RSTFLTSS_SHIFT   (2U)
 
#define RCM_RPFC_RSTFLTSS(x)   (((uint8_t)(((uint8_t)(x)) << RCM_RPFC_RSTFLTSS_SHIFT)) & RCM_RPFC_RSTFLTSS_MASK)
 
RPFW - Reset Pin Filter Width register
#define RCM_RPFW_RSTFLTSEL_MASK   (0x1FU)
 
#define RCM_RPFW_RSTFLTSEL_SHIFT   (0U)
 
#define RCM_RPFW_RSTFLTSEL(x)   (((uint8_t)(((uint8_t)(x)) << RCM_RPFW_RSTFLTSEL_SHIFT)) & RCM_RPFW_RSTFLTSEL_MASK)
 
MR - Mode Register
#define RCM_MR_EZP_MS_MASK   (0x2U)
 
#define RCM_MR_EZP_MS_SHIFT   (1U)
 
#define RCM_MR_EZP_MS(x)   (((uint8_t)(((uint8_t)(x)) << RCM_MR_EZP_MS_SHIFT)) & RCM_MR_EZP_MS_MASK)
 
REG - Register file register
#define RFSYS_REG_LL_MASK   (0xFFU)
 
#define RFSYS_REG_LL_SHIFT   (0U)
 
#define RFSYS_REG_LL(x)   (((uint32_t)(((uint32_t)(x)) << RFSYS_REG_LL_SHIFT)) & RFSYS_REG_LL_MASK)
 
#define RFSYS_REG_LH_MASK   (0xFF00U)
 
#define RFSYS_REG_LH_SHIFT   (8U)
 
#define RFSYS_REG_LH(x)   (((uint32_t)(((uint32_t)(x)) << RFSYS_REG_LH_SHIFT)) & RFSYS_REG_LH_MASK)
 
#define RFSYS_REG_HL_MASK   (0xFF0000U)
 
#define RFSYS_REG_HL_SHIFT   (16U)
 
#define RFSYS_REG_HL(x)   (((uint32_t)(((uint32_t)(x)) << RFSYS_REG_HL_SHIFT)) & RFSYS_REG_HL_MASK)
 
#define RFSYS_REG_HH_MASK   (0xFF000000U)
 
#define RFSYS_REG_HH_SHIFT   (24U)
 
#define RFSYS_REG_HH(x)   (((uint32_t)(((uint32_t)(x)) << RFSYS_REG_HH_SHIFT)) & RFSYS_REG_HH_MASK)
 
#define RFSYS_REG_COUNT   (8U)
 
REG - VBAT register file register
#define RFVBAT_REG_LL_MASK   (0xFFU)
 
#define RFVBAT_REG_LL_SHIFT   (0U)
 
#define RFVBAT_REG_LL(x)   (((uint32_t)(((uint32_t)(x)) << RFVBAT_REG_LL_SHIFT)) & RFVBAT_REG_LL_MASK)
 
#define RFVBAT_REG_LH_MASK   (0xFF00U)
 
#define RFVBAT_REG_LH_SHIFT   (8U)
 
#define RFVBAT_REG_LH(x)   (((uint32_t)(((uint32_t)(x)) << RFVBAT_REG_LH_SHIFT)) & RFVBAT_REG_LH_MASK)
 
#define RFVBAT_REG_HL_MASK   (0xFF0000U)
 
#define RFVBAT_REG_HL_SHIFT   (16U)
 
#define RFVBAT_REG_HL(x)   (((uint32_t)(((uint32_t)(x)) << RFVBAT_REG_HL_SHIFT)) & RFVBAT_REG_HL_MASK)
 
#define RFVBAT_REG_HH_MASK   (0xFF000000U)
 
#define RFVBAT_REG_HH_SHIFT   (24U)
 
#define RFVBAT_REG_HH(x)   (((uint32_t)(((uint32_t)(x)) << RFVBAT_REG_HH_SHIFT)) & RFVBAT_REG_HH_MASK)
 
#define RFVBAT_REG_COUNT   (8U)
 
CR - RNGA Control Register
#define RNG_CR_GO_MASK   (0x1U)
 
#define RNG_CR_GO_SHIFT   (0U)
 
#define RNG_CR_GO(x)   (((uint32_t)(((uint32_t)(x)) << RNG_CR_GO_SHIFT)) & RNG_CR_GO_MASK)
 
#define RNG_CR_HA_MASK   (0x2U)
 
#define RNG_CR_HA_SHIFT   (1U)
 
#define RNG_CR_HA(x)   (((uint32_t)(((uint32_t)(x)) << RNG_CR_HA_SHIFT)) & RNG_CR_HA_MASK)
 
#define RNG_CR_INTM_MASK   (0x4U)
 
#define RNG_CR_INTM_SHIFT   (2U)
 
#define RNG_CR_INTM(x)   (((uint32_t)(((uint32_t)(x)) << RNG_CR_INTM_SHIFT)) & RNG_CR_INTM_MASK)
 
#define RNG_CR_CLRI_MASK   (0x8U)
 
#define RNG_CR_CLRI_SHIFT   (3U)
 
#define RNG_CR_CLRI(x)   (((uint32_t)(((uint32_t)(x)) << RNG_CR_CLRI_SHIFT)) & RNG_CR_CLRI_MASK)
 
#define RNG_CR_SLP_MASK   (0x10U)
 
#define RNG_CR_SLP_SHIFT   (4U)
 
#define RNG_CR_SLP(x)   (((uint32_t)(((uint32_t)(x)) << RNG_CR_SLP_SHIFT)) & RNG_CR_SLP_MASK)
 
SR - RNGA Status Register
#define RNG_SR_SECV_MASK   (0x1U)
 
#define RNG_SR_SECV_SHIFT   (0U)
 
#define RNG_SR_SECV(x)   (((uint32_t)(((uint32_t)(x)) << RNG_SR_SECV_SHIFT)) & RNG_SR_SECV_MASK)
 
#define RNG_SR_LRS_MASK   (0x2U)
 
#define RNG_SR_LRS_SHIFT   (1U)
 
#define RNG_SR_LRS(x)   (((uint32_t)(((uint32_t)(x)) << RNG_SR_LRS_SHIFT)) & RNG_SR_LRS_MASK)
 
#define RNG_SR_ORU_MASK   (0x4U)
 
#define RNG_SR_ORU_SHIFT   (2U)
 
#define RNG_SR_ORU(x)   (((uint32_t)(((uint32_t)(x)) << RNG_SR_ORU_SHIFT)) & RNG_SR_ORU_MASK)
 
#define RNG_SR_ERRI_MASK   (0x8U)
 
#define RNG_SR_ERRI_SHIFT   (3U)
 
#define RNG_SR_ERRI(x)   (((uint32_t)(((uint32_t)(x)) << RNG_SR_ERRI_SHIFT)) & RNG_SR_ERRI_MASK)
 
#define RNG_SR_SLP_MASK   (0x10U)
 
#define RNG_SR_SLP_SHIFT   (4U)
 
#define RNG_SR_SLP(x)   (((uint32_t)(((uint32_t)(x)) << RNG_SR_SLP_SHIFT)) & RNG_SR_SLP_MASK)
 
#define RNG_SR_OREG_LVL_MASK   (0xFF00U)
 
#define RNG_SR_OREG_LVL_SHIFT   (8U)
 
#define RNG_SR_OREG_LVL(x)   (((uint32_t)(((uint32_t)(x)) << RNG_SR_OREG_LVL_SHIFT)) & RNG_SR_OREG_LVL_MASK)
 
#define RNG_SR_OREG_SIZE_MASK   (0xFF0000U)
 
#define RNG_SR_OREG_SIZE_SHIFT   (16U)
 
#define RNG_SR_OREG_SIZE(x)   (((uint32_t)(((uint32_t)(x)) << RNG_SR_OREG_SIZE_SHIFT)) & RNG_SR_OREG_SIZE_MASK)
 
ER - RNGA Entropy Register
#define RNG_ER_EXT_ENT_MASK   (0xFFFFFFFFU)
 
#define RNG_ER_EXT_ENT_SHIFT   (0U)
 
#define RNG_ER_EXT_ENT(x)   (((uint32_t)(((uint32_t)(x)) << RNG_ER_EXT_ENT_SHIFT)) & RNG_ER_EXT_ENT_MASK)
 
OR - RNGA Output Register
#define RNG_OR_RANDOUT_MASK   (0xFFFFFFFFU)
 
#define RNG_OR_RANDOUT_SHIFT   (0U)
 
#define RNG_OR_RANDOUT(x)   (((uint32_t)(((uint32_t)(x)) << RNG_OR_RANDOUT_SHIFT)) & RNG_OR_RANDOUT_MASK)
 
TSR - RTC Time Seconds Register
#define RTC_TSR_TSR_MASK   (0xFFFFFFFFU)
 
#define RTC_TSR_TSR_SHIFT   (0U)
 
#define RTC_TSR_TSR(x)   (((uint32_t)(((uint32_t)(x)) << RTC_TSR_TSR_SHIFT)) & RTC_TSR_TSR_MASK)
 
TPR - RTC Time Prescaler Register
#define RTC_TPR_TPR_MASK   (0xFFFFU)
 
#define RTC_TPR_TPR_SHIFT   (0U)
 
#define RTC_TPR_TPR(x)   (((uint32_t)(((uint32_t)(x)) << RTC_TPR_TPR_SHIFT)) & RTC_TPR_TPR_MASK)
 
TAR - RTC Time Alarm Register
#define RTC_TAR_TAR_MASK   (0xFFFFFFFFU)
 
#define RTC_TAR_TAR_SHIFT   (0U)
 
#define RTC_TAR_TAR(x)   (((uint32_t)(((uint32_t)(x)) << RTC_TAR_TAR_SHIFT)) & RTC_TAR_TAR_MASK)
 
TCR - RTC Time Compensation Register
#define RTC_TCR_TCR_MASK   (0xFFU)
 
#define RTC_TCR_TCR_SHIFT   (0U)
 
#define RTC_TCR_TCR(x)   (((uint32_t)(((uint32_t)(x)) << RTC_TCR_TCR_SHIFT)) & RTC_TCR_TCR_MASK)
 
#define RTC_TCR_CIR_MASK   (0xFF00U)
 
#define RTC_TCR_CIR_SHIFT   (8U)
 
#define RTC_TCR_CIR(x)   (((uint32_t)(((uint32_t)(x)) << RTC_TCR_CIR_SHIFT)) & RTC_TCR_CIR_MASK)
 
#define RTC_TCR_TCV_MASK   (0xFF0000U)
 
#define RTC_TCR_TCV_SHIFT   (16U)
 
#define RTC_TCR_TCV(x)   (((uint32_t)(((uint32_t)(x)) << RTC_TCR_TCV_SHIFT)) & RTC_TCR_TCV_MASK)
 
#define RTC_TCR_CIC_MASK   (0xFF000000U)
 
#define RTC_TCR_CIC_SHIFT   (24U)
 
#define RTC_TCR_CIC(x)   (((uint32_t)(((uint32_t)(x)) << RTC_TCR_CIC_SHIFT)) & RTC_TCR_CIC_MASK)
 
CR - RTC Control Register
#define RTC_CR_SWR_MASK   (0x1U)
 
#define RTC_CR_SWR_SHIFT   (0U)
 
#define RTC_CR_SWR(x)   (((uint32_t)(((uint32_t)(x)) << RTC_CR_SWR_SHIFT)) & RTC_CR_SWR_MASK)
 
#define RTC_CR_WPE_MASK   (0x2U)
 
#define RTC_CR_WPE_SHIFT   (1U)
 
#define RTC_CR_WPE(x)   (((uint32_t)(((uint32_t)(x)) << RTC_CR_WPE_SHIFT)) & RTC_CR_WPE_MASK)
 
#define RTC_CR_SUP_MASK   (0x4U)
 
#define RTC_CR_SUP_SHIFT   (2U)
 
#define RTC_CR_SUP(x)   (((uint32_t)(((uint32_t)(x)) << RTC_CR_SUP_SHIFT)) & RTC_CR_SUP_MASK)
 
#define RTC_CR_UM_MASK   (0x8U)
 
#define RTC_CR_UM_SHIFT   (3U)
 
#define RTC_CR_UM(x)   (((uint32_t)(((uint32_t)(x)) << RTC_CR_UM_SHIFT)) & RTC_CR_UM_MASK)
 
#define RTC_CR_WPS_MASK   (0x10U)
 
#define RTC_CR_WPS_SHIFT   (4U)
 
#define RTC_CR_WPS(x)   (((uint32_t)(((uint32_t)(x)) << RTC_CR_WPS_SHIFT)) & RTC_CR_WPS_MASK)
 
#define RTC_CR_OSCE_MASK   (0x100U)
 
#define RTC_CR_OSCE_SHIFT   (8U)
 
#define RTC_CR_OSCE(x)   (((uint32_t)(((uint32_t)(x)) << RTC_CR_OSCE_SHIFT)) & RTC_CR_OSCE_MASK)
 
#define RTC_CR_CLKO_MASK   (0x200U)
 
#define RTC_CR_CLKO_SHIFT   (9U)
 
#define RTC_CR_CLKO(x)   (((uint32_t)(((uint32_t)(x)) << RTC_CR_CLKO_SHIFT)) & RTC_CR_CLKO_MASK)
 
#define RTC_CR_SC16P_MASK   (0x400U)
 
#define RTC_CR_SC16P_SHIFT   (10U)
 
#define RTC_CR_SC16P(x)   (((uint32_t)(((uint32_t)(x)) << RTC_CR_SC16P_SHIFT)) & RTC_CR_SC16P_MASK)
 
#define RTC_CR_SC8P_MASK   (0x800U)
 
#define RTC_CR_SC8P_SHIFT   (11U)
 
#define RTC_CR_SC8P(x)   (((uint32_t)(((uint32_t)(x)) << RTC_CR_SC8P_SHIFT)) & RTC_CR_SC8P_MASK)
 
#define RTC_CR_SC4P_MASK   (0x1000U)
 
#define RTC_CR_SC4P_SHIFT   (12U)
 
#define RTC_CR_SC4P(x)   (((uint32_t)(((uint32_t)(x)) << RTC_CR_SC4P_SHIFT)) & RTC_CR_SC4P_MASK)
 
#define RTC_CR_SC2P_MASK   (0x2000U)
 
#define RTC_CR_SC2P_SHIFT   (13U)
 
#define RTC_CR_SC2P(x)   (((uint32_t)(((uint32_t)(x)) << RTC_CR_SC2P_SHIFT)) & RTC_CR_SC2P_MASK)
 
SR - RTC Status Register
#define RTC_SR_TIF_MASK   (0x1U)
 
#define RTC_SR_TIF_SHIFT   (0U)
 
#define RTC_SR_TIF(x)   (((uint32_t)(((uint32_t)(x)) << RTC_SR_TIF_SHIFT)) & RTC_SR_TIF_MASK)
 
#define RTC_SR_TOF_MASK   (0x2U)
 
#define RTC_SR_TOF_SHIFT   (1U)
 
#define RTC_SR_TOF(x)   (((uint32_t)(((uint32_t)(x)) << RTC_SR_TOF_SHIFT)) & RTC_SR_TOF_MASK)
 
#define RTC_SR_TAF_MASK   (0x4U)
 
#define RTC_SR_TAF_SHIFT   (2U)
 
#define RTC_SR_TAF(x)   (((uint32_t)(((uint32_t)(x)) << RTC_SR_TAF_SHIFT)) & RTC_SR_TAF_MASK)
 
#define RTC_SR_TCE_MASK   (0x10U)
 
#define RTC_SR_TCE_SHIFT   (4U)
 
#define RTC_SR_TCE(x)   (((uint32_t)(((uint32_t)(x)) << RTC_SR_TCE_SHIFT)) & RTC_SR_TCE_MASK)
 
LR - RTC Lock Register
#define RTC_LR_TCL_MASK   (0x8U)
 
#define RTC_LR_TCL_SHIFT   (3U)
 
#define RTC_LR_TCL(x)   (((uint32_t)(((uint32_t)(x)) << RTC_LR_TCL_SHIFT)) & RTC_LR_TCL_MASK)
 
#define RTC_LR_CRL_MASK   (0x10U)
 
#define RTC_LR_CRL_SHIFT   (4U)
 
#define RTC_LR_CRL(x)   (((uint32_t)(((uint32_t)(x)) << RTC_LR_CRL_SHIFT)) & RTC_LR_CRL_MASK)
 
#define RTC_LR_SRL_MASK   (0x20U)
 
#define RTC_LR_SRL_SHIFT   (5U)
 
#define RTC_LR_SRL(x)   (((uint32_t)(((uint32_t)(x)) << RTC_LR_SRL_SHIFT)) & RTC_LR_SRL_MASK)
 
#define RTC_LR_LRL_MASK   (0x40U)
 
#define RTC_LR_LRL_SHIFT   (6U)
 
#define RTC_LR_LRL(x)   (((uint32_t)(((uint32_t)(x)) << RTC_LR_LRL_SHIFT)) & RTC_LR_LRL_MASK)
 
IER - RTC Interrupt Enable Register
#define RTC_IER_TIIE_MASK   (0x1U)
 
#define RTC_IER_TIIE_SHIFT   (0U)
 
#define RTC_IER_TIIE(x)   (((uint32_t)(((uint32_t)(x)) << RTC_IER_TIIE_SHIFT)) & RTC_IER_TIIE_MASK)
 
#define RTC_IER_TOIE_MASK   (0x2U)
 
#define RTC_IER_TOIE_SHIFT   (1U)
 
#define RTC_IER_TOIE(x)   (((uint32_t)(((uint32_t)(x)) << RTC_IER_TOIE_SHIFT)) & RTC_IER_TOIE_MASK)
 
#define RTC_IER_TAIE_MASK   (0x4U)
 
#define RTC_IER_TAIE_SHIFT   (2U)
 
#define RTC_IER_TAIE(x)   (((uint32_t)(((uint32_t)(x)) << RTC_IER_TAIE_SHIFT)) & RTC_IER_TAIE_MASK)
 
#define RTC_IER_TSIE_MASK   (0x10U)
 
#define RTC_IER_TSIE_SHIFT   (4U)
 
#define RTC_IER_TSIE(x)   (((uint32_t)(((uint32_t)(x)) << RTC_IER_TSIE_SHIFT)) & RTC_IER_TSIE_MASK)
 
#define RTC_IER_WPON_MASK   (0x80U)
 
#define RTC_IER_WPON_SHIFT   (7U)
 
#define RTC_IER_WPON(x)   (((uint32_t)(((uint32_t)(x)) << RTC_IER_WPON_SHIFT)) & RTC_IER_WPON_MASK)
 
WAR - RTC Write Access Register
#define RTC_WAR_TSRW_MASK   (0x1U)
 
#define RTC_WAR_TSRW_SHIFT   (0U)
 
#define RTC_WAR_TSRW(x)   (((uint32_t)(((uint32_t)(x)) << RTC_WAR_TSRW_SHIFT)) & RTC_WAR_TSRW_MASK)
 
#define RTC_WAR_TPRW_MASK   (0x2U)
 
#define RTC_WAR_TPRW_SHIFT   (1U)
 
#define RTC_WAR_TPRW(x)   (((uint32_t)(((uint32_t)(x)) << RTC_WAR_TPRW_SHIFT)) & RTC_WAR_TPRW_MASK)
 
#define RTC_WAR_TARW_MASK   (0x4U)
 
#define RTC_WAR_TARW_SHIFT   (2U)
 
#define RTC_WAR_TARW(x)   (((uint32_t)(((uint32_t)(x)) << RTC_WAR_TARW_SHIFT)) & RTC_WAR_TARW_MASK)
 
#define RTC_WAR_TCRW_MASK   (0x8U)
 
#define RTC_WAR_TCRW_SHIFT   (3U)
 
#define RTC_WAR_TCRW(x)   (((uint32_t)(((uint32_t)(x)) << RTC_WAR_TCRW_SHIFT)) & RTC_WAR_TCRW_MASK)
 
#define RTC_WAR_CRW_MASK   (0x10U)
 
#define RTC_WAR_CRW_SHIFT   (4U)
 
#define RTC_WAR_CRW(x)   (((uint32_t)(((uint32_t)(x)) << RTC_WAR_CRW_SHIFT)) & RTC_WAR_CRW_MASK)
 
#define RTC_WAR_SRW_MASK   (0x20U)
 
#define RTC_WAR_SRW_SHIFT   (5U)
 
#define RTC_WAR_SRW(x)   (((uint32_t)(((uint32_t)(x)) << RTC_WAR_SRW_SHIFT)) & RTC_WAR_SRW_MASK)
 
#define RTC_WAR_LRW_MASK   (0x40U)
 
#define RTC_WAR_LRW_SHIFT   (6U)
 
#define RTC_WAR_LRW(x)   (((uint32_t)(((uint32_t)(x)) << RTC_WAR_LRW_SHIFT)) & RTC_WAR_LRW_MASK)
 
#define RTC_WAR_IERW_MASK   (0x80U)
 
#define RTC_WAR_IERW_SHIFT   (7U)
 
#define RTC_WAR_IERW(x)   (((uint32_t)(((uint32_t)(x)) << RTC_WAR_IERW_SHIFT)) & RTC_WAR_IERW_MASK)
 
RAR - RTC Read Access Register
#define RTC_RAR_TSRR_MASK   (0x1U)
 
#define RTC_RAR_TSRR_SHIFT   (0U)
 
#define RTC_RAR_TSRR(x)   (((uint32_t)(((uint32_t)(x)) << RTC_RAR_TSRR_SHIFT)) & RTC_RAR_TSRR_MASK)
 
#define RTC_RAR_TPRR_MASK   (0x2U)
 
#define RTC_RAR_TPRR_SHIFT   (1U)
 
#define RTC_RAR_TPRR(x)   (((uint32_t)(((uint32_t)(x)) << RTC_RAR_TPRR_SHIFT)) & RTC_RAR_TPRR_MASK)
 
#define RTC_RAR_TARR_MASK   (0x4U)
 
#define RTC_RAR_TARR_SHIFT   (2U)
 
#define RTC_RAR_TARR(x)   (((uint32_t)(((uint32_t)(x)) << RTC_RAR_TARR_SHIFT)) & RTC_RAR_TARR_MASK)
 
#define RTC_RAR_TCRR_MASK   (0x8U)
 
#define RTC_RAR_TCRR_SHIFT   (3U)
 
#define RTC_RAR_TCRR(x)   (((uint32_t)(((uint32_t)(x)) << RTC_RAR_TCRR_SHIFT)) & RTC_RAR_TCRR_MASK)
 
#define RTC_RAR_CRR_MASK   (0x10U)
 
#define RTC_RAR_CRR_SHIFT   (4U)
 
#define RTC_RAR_CRR(x)   (((uint32_t)(((uint32_t)(x)) << RTC_RAR_CRR_SHIFT)) & RTC_RAR_CRR_MASK)
 
#define RTC_RAR_SRR_MASK   (0x20U)
 
#define RTC_RAR_SRR_SHIFT   (5U)
 
#define RTC_RAR_SRR(x)   (((uint32_t)(((uint32_t)(x)) << RTC_RAR_SRR_SHIFT)) & RTC_RAR_SRR_MASK)
 
#define RTC_RAR_LRR_MASK   (0x40U)
 
#define RTC_RAR_LRR_SHIFT   (6U)
 
#define RTC_RAR_LRR(x)   (((uint32_t)(((uint32_t)(x)) << RTC_RAR_LRR_SHIFT)) & RTC_RAR_LRR_MASK)
 
#define RTC_RAR_IERR_MASK   (0x80U)
 
#define RTC_RAR_IERR_SHIFT   (7U)
 
#define RTC_RAR_IERR(x)   (((uint32_t)(((uint32_t)(x)) << RTC_RAR_IERR_SHIFT)) & RTC_RAR_IERR_MASK)
 
DSADDR - DMA System Address register
#define SDHC_DSADDR_DSADDR_MASK   (0xFFFFFFFCU)
 
#define SDHC_DSADDR_DSADDR_SHIFT   (2U)
 
#define SDHC_DSADDR_DSADDR(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_DSADDR_DSADDR_SHIFT)) & SDHC_DSADDR_DSADDR_MASK)
 
BLKATTR - Block Attributes register
#define SDHC_BLKATTR_BLKSIZE_MASK   (0x1FFFU)
 
#define SDHC_BLKATTR_BLKSIZE_SHIFT   (0U)
 
#define SDHC_BLKATTR_BLKSIZE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_BLKATTR_BLKSIZE_SHIFT)) & SDHC_BLKATTR_BLKSIZE_MASK)
 
#define SDHC_BLKATTR_BLKCNT_MASK   (0xFFFF0000U)
 
#define SDHC_BLKATTR_BLKCNT_SHIFT   (16U)
 
#define SDHC_BLKATTR_BLKCNT(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_BLKATTR_BLKCNT_SHIFT)) & SDHC_BLKATTR_BLKCNT_MASK)
 
CMDARG - Command Argument register
#define SDHC_CMDARG_CMDARG_MASK   (0xFFFFFFFFU)
 
#define SDHC_CMDARG_CMDARG_SHIFT   (0U)
 
#define SDHC_CMDARG_CMDARG(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_CMDARG_CMDARG_SHIFT)) & SDHC_CMDARG_CMDARG_MASK)
 
XFERTYP - Transfer Type register
#define SDHC_XFERTYP_DMAEN_MASK   (0x1U)
 
#define SDHC_XFERTYP_DMAEN_SHIFT   (0U)
 
#define SDHC_XFERTYP_DMAEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_XFERTYP_DMAEN_SHIFT)) & SDHC_XFERTYP_DMAEN_MASK)
 
#define SDHC_XFERTYP_BCEN_MASK   (0x2U)
 
#define SDHC_XFERTYP_BCEN_SHIFT   (1U)
 
#define SDHC_XFERTYP_BCEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_XFERTYP_BCEN_SHIFT)) & SDHC_XFERTYP_BCEN_MASK)
 
#define SDHC_XFERTYP_AC12EN_MASK   (0x4U)
 
#define SDHC_XFERTYP_AC12EN_SHIFT   (2U)
 
#define SDHC_XFERTYP_AC12EN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_XFERTYP_AC12EN_SHIFT)) & SDHC_XFERTYP_AC12EN_MASK)
 
#define SDHC_XFERTYP_DTDSEL_MASK   (0x10U)
 
#define SDHC_XFERTYP_DTDSEL_SHIFT   (4U)
 
#define SDHC_XFERTYP_DTDSEL(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_XFERTYP_DTDSEL_SHIFT)) & SDHC_XFERTYP_DTDSEL_MASK)
 
#define SDHC_XFERTYP_MSBSEL_MASK   (0x20U)
 
#define SDHC_XFERTYP_MSBSEL_SHIFT   (5U)
 
#define SDHC_XFERTYP_MSBSEL(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_XFERTYP_MSBSEL_SHIFT)) & SDHC_XFERTYP_MSBSEL_MASK)
 
#define SDHC_XFERTYP_RSPTYP_MASK   (0x30000U)
 
#define SDHC_XFERTYP_RSPTYP_SHIFT   (16U)
 
#define SDHC_XFERTYP_RSPTYP(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_XFERTYP_RSPTYP_SHIFT)) & SDHC_XFERTYP_RSPTYP_MASK)
 
#define SDHC_XFERTYP_CCCEN_MASK   (0x80000U)
 
#define SDHC_XFERTYP_CCCEN_SHIFT   (19U)
 
#define SDHC_XFERTYP_CCCEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_XFERTYP_CCCEN_SHIFT)) & SDHC_XFERTYP_CCCEN_MASK)
 
#define SDHC_XFERTYP_CICEN_MASK   (0x100000U)
 
#define SDHC_XFERTYP_CICEN_SHIFT   (20U)
 
#define SDHC_XFERTYP_CICEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_XFERTYP_CICEN_SHIFT)) & SDHC_XFERTYP_CICEN_MASK)
 
#define SDHC_XFERTYP_DPSEL_MASK   (0x200000U)
 
#define SDHC_XFERTYP_DPSEL_SHIFT   (21U)
 
#define SDHC_XFERTYP_DPSEL(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_XFERTYP_DPSEL_SHIFT)) & SDHC_XFERTYP_DPSEL_MASK)
 
#define SDHC_XFERTYP_CMDTYP_MASK   (0xC00000U)
 
#define SDHC_XFERTYP_CMDTYP_SHIFT   (22U)
 
#define SDHC_XFERTYP_CMDTYP(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_XFERTYP_CMDTYP_SHIFT)) & SDHC_XFERTYP_CMDTYP_MASK)
 
#define SDHC_XFERTYP_CMDINX_MASK   (0x3F000000U)
 
#define SDHC_XFERTYP_CMDINX_SHIFT   (24U)
 
#define SDHC_XFERTYP_CMDINX(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_XFERTYP_CMDINX_SHIFT)) & SDHC_XFERTYP_CMDINX_MASK)
 
CMDRSP - Command Response 0..Command Response 3
#define SDHC_CMDRSP_CMDRSP0_MASK   (0xFFFFFFFFU)
 
#define SDHC_CMDRSP_CMDRSP0_SHIFT   (0U)
 
#define SDHC_CMDRSP_CMDRSP0(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_CMDRSP_CMDRSP0_SHIFT)) & SDHC_CMDRSP_CMDRSP0_MASK)
 
#define SDHC_CMDRSP_CMDRSP1_MASK   (0xFFFFFFFFU)
 
#define SDHC_CMDRSP_CMDRSP1_SHIFT   (0U)
 
#define SDHC_CMDRSP_CMDRSP1(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_CMDRSP_CMDRSP1_SHIFT)) & SDHC_CMDRSP_CMDRSP1_MASK)
 
#define SDHC_CMDRSP_CMDRSP2_MASK   (0xFFFFFFFFU)
 
#define SDHC_CMDRSP_CMDRSP2_SHIFT   (0U)
 
#define SDHC_CMDRSP_CMDRSP2(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_CMDRSP_CMDRSP2_SHIFT)) & SDHC_CMDRSP_CMDRSP2_MASK)
 
#define SDHC_CMDRSP_CMDRSP3_MASK   (0xFFFFFFFFU)
 
#define SDHC_CMDRSP_CMDRSP3_SHIFT   (0U)
 
#define SDHC_CMDRSP_CMDRSP3(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_CMDRSP_CMDRSP3_SHIFT)) & SDHC_CMDRSP_CMDRSP3_MASK)
 
#define SDHC_CMDRSP_COUNT   (4U)
 
DATPORT - Buffer Data Port register
#define SDHC_DATPORT_DATCONT_MASK   (0xFFFFFFFFU)
 
#define SDHC_DATPORT_DATCONT_SHIFT   (0U)
 
#define SDHC_DATPORT_DATCONT(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_DATPORT_DATCONT_SHIFT)) & SDHC_DATPORT_DATCONT_MASK)
 
PRSSTAT - Present State register
#define SDHC_PRSSTAT_CIHB_MASK   (0x1U)
 
#define SDHC_PRSSTAT_CIHB_SHIFT   (0U)
 
#define SDHC_PRSSTAT_CIHB(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PRSSTAT_CIHB_SHIFT)) & SDHC_PRSSTAT_CIHB_MASK)
 
#define SDHC_PRSSTAT_CDIHB_MASK   (0x2U)
 
#define SDHC_PRSSTAT_CDIHB_SHIFT   (1U)
 
#define SDHC_PRSSTAT_CDIHB(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PRSSTAT_CDIHB_SHIFT)) & SDHC_PRSSTAT_CDIHB_MASK)
 
#define SDHC_PRSSTAT_DLA_MASK   (0x4U)
 
#define SDHC_PRSSTAT_DLA_SHIFT   (2U)
 
#define SDHC_PRSSTAT_DLA(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PRSSTAT_DLA_SHIFT)) & SDHC_PRSSTAT_DLA_MASK)
 
#define SDHC_PRSSTAT_SDSTB_MASK   (0x8U)
 
#define SDHC_PRSSTAT_SDSTB_SHIFT   (3U)
 
#define SDHC_PRSSTAT_SDSTB(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PRSSTAT_SDSTB_SHIFT)) & SDHC_PRSSTAT_SDSTB_MASK)
 
#define SDHC_PRSSTAT_IPGOFF_MASK   (0x10U)
 
#define SDHC_PRSSTAT_IPGOFF_SHIFT   (4U)
 
#define SDHC_PRSSTAT_IPGOFF(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PRSSTAT_IPGOFF_SHIFT)) & SDHC_PRSSTAT_IPGOFF_MASK)
 
#define SDHC_PRSSTAT_HCKOFF_MASK   (0x20U)
 
#define SDHC_PRSSTAT_HCKOFF_SHIFT   (5U)
 
#define SDHC_PRSSTAT_HCKOFF(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PRSSTAT_HCKOFF_SHIFT)) & SDHC_PRSSTAT_HCKOFF_MASK)
 
#define SDHC_PRSSTAT_PEROFF_MASK   (0x40U)
 
#define SDHC_PRSSTAT_PEROFF_SHIFT   (6U)
 
#define SDHC_PRSSTAT_PEROFF(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PRSSTAT_PEROFF_SHIFT)) & SDHC_PRSSTAT_PEROFF_MASK)
 
#define SDHC_PRSSTAT_SDOFF_MASK   (0x80U)
 
#define SDHC_PRSSTAT_SDOFF_SHIFT   (7U)
 
#define SDHC_PRSSTAT_SDOFF(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PRSSTAT_SDOFF_SHIFT)) & SDHC_PRSSTAT_SDOFF_MASK)
 
#define SDHC_PRSSTAT_WTA_MASK   (0x100U)
 
#define SDHC_PRSSTAT_WTA_SHIFT   (8U)
 
#define SDHC_PRSSTAT_WTA(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PRSSTAT_WTA_SHIFT)) & SDHC_PRSSTAT_WTA_MASK)
 
#define SDHC_PRSSTAT_RTA_MASK   (0x200U)
 
#define SDHC_PRSSTAT_RTA_SHIFT   (9U)
 
#define SDHC_PRSSTAT_RTA(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PRSSTAT_RTA_SHIFT)) & SDHC_PRSSTAT_RTA_MASK)
 
#define SDHC_PRSSTAT_BWEN_MASK   (0x400U)
 
#define SDHC_PRSSTAT_BWEN_SHIFT   (10U)
 
#define SDHC_PRSSTAT_BWEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PRSSTAT_BWEN_SHIFT)) & SDHC_PRSSTAT_BWEN_MASK)
 
#define SDHC_PRSSTAT_BREN_MASK   (0x800U)
 
#define SDHC_PRSSTAT_BREN_SHIFT   (11U)
 
#define SDHC_PRSSTAT_BREN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PRSSTAT_BREN_SHIFT)) & SDHC_PRSSTAT_BREN_MASK)
 
#define SDHC_PRSSTAT_CINS_MASK   (0x10000U)
 
#define SDHC_PRSSTAT_CINS_SHIFT   (16U)
 
#define SDHC_PRSSTAT_CINS(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PRSSTAT_CINS_SHIFT)) & SDHC_PRSSTAT_CINS_MASK)
 
#define SDHC_PRSSTAT_CLSL_MASK   (0x800000U)
 
#define SDHC_PRSSTAT_CLSL_SHIFT   (23U)
 
#define SDHC_PRSSTAT_CLSL(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PRSSTAT_CLSL_SHIFT)) & SDHC_PRSSTAT_CLSL_MASK)
 
#define SDHC_PRSSTAT_DLSL_MASK   (0xFF000000U)
 
#define SDHC_PRSSTAT_DLSL_SHIFT   (24U)
 
#define SDHC_PRSSTAT_DLSL(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PRSSTAT_DLSL_SHIFT)) & SDHC_PRSSTAT_DLSL_MASK)
 
PROCTL - Protocol Control register
#define SDHC_PROCTL_LCTL_MASK   (0x1U)
 
#define SDHC_PROCTL_LCTL_SHIFT   (0U)
 
#define SDHC_PROCTL_LCTL(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PROCTL_LCTL_SHIFT)) & SDHC_PROCTL_LCTL_MASK)
 
#define SDHC_PROCTL_DTW_MASK   (0x6U)
 
#define SDHC_PROCTL_DTW_SHIFT   (1U)
 
#define SDHC_PROCTL_DTW(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PROCTL_DTW_SHIFT)) & SDHC_PROCTL_DTW_MASK)
 
#define SDHC_PROCTL_D3CD_MASK   (0x8U)
 
#define SDHC_PROCTL_D3CD_SHIFT   (3U)
 
#define SDHC_PROCTL_D3CD(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PROCTL_D3CD_SHIFT)) & SDHC_PROCTL_D3CD_MASK)
 
#define SDHC_PROCTL_EMODE_MASK   (0x30U)
 
#define SDHC_PROCTL_EMODE_SHIFT   (4U)
 
#define SDHC_PROCTL_EMODE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PROCTL_EMODE_SHIFT)) & SDHC_PROCTL_EMODE_MASK)
 
#define SDHC_PROCTL_CDTL_MASK   (0x40U)
 
#define SDHC_PROCTL_CDTL_SHIFT   (6U)
 
#define SDHC_PROCTL_CDTL(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PROCTL_CDTL_SHIFT)) & SDHC_PROCTL_CDTL_MASK)
 
#define SDHC_PROCTL_CDSS_MASK   (0x80U)
 
#define SDHC_PROCTL_CDSS_SHIFT   (7U)
 
#define SDHC_PROCTL_CDSS(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PROCTL_CDSS_SHIFT)) & SDHC_PROCTL_CDSS_MASK)
 
#define SDHC_PROCTL_DMAS_MASK   (0x300U)
 
#define SDHC_PROCTL_DMAS_SHIFT   (8U)
 
#define SDHC_PROCTL_DMAS(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PROCTL_DMAS_SHIFT)) & SDHC_PROCTL_DMAS_MASK)
 
#define SDHC_PROCTL_SABGREQ_MASK   (0x10000U)
 
#define SDHC_PROCTL_SABGREQ_SHIFT   (16U)
 
#define SDHC_PROCTL_SABGREQ(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PROCTL_SABGREQ_SHIFT)) & SDHC_PROCTL_SABGREQ_MASK)
 
#define SDHC_PROCTL_CREQ_MASK   (0x20000U)
 
#define SDHC_PROCTL_CREQ_SHIFT   (17U)
 
#define SDHC_PROCTL_CREQ(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PROCTL_CREQ_SHIFT)) & SDHC_PROCTL_CREQ_MASK)
 
#define SDHC_PROCTL_RWCTL_MASK   (0x40000U)
 
#define SDHC_PROCTL_RWCTL_SHIFT   (18U)
 
#define SDHC_PROCTL_RWCTL(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PROCTL_RWCTL_SHIFT)) & SDHC_PROCTL_RWCTL_MASK)
 
#define SDHC_PROCTL_IABG_MASK   (0x80000U)
 
#define SDHC_PROCTL_IABG_SHIFT   (19U)
 
#define SDHC_PROCTL_IABG(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PROCTL_IABG_SHIFT)) & SDHC_PROCTL_IABG_MASK)
 
#define SDHC_PROCTL_WECINT_MASK   (0x1000000U)
 
#define SDHC_PROCTL_WECINT_SHIFT   (24U)
 
#define SDHC_PROCTL_WECINT(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PROCTL_WECINT_SHIFT)) & SDHC_PROCTL_WECINT_MASK)
 
#define SDHC_PROCTL_WECINS_MASK   (0x2000000U)
 
#define SDHC_PROCTL_WECINS_SHIFT   (25U)
 
#define SDHC_PROCTL_WECINS(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PROCTL_WECINS_SHIFT)) & SDHC_PROCTL_WECINS_MASK)
 
#define SDHC_PROCTL_WECRM_MASK   (0x4000000U)
 
#define SDHC_PROCTL_WECRM_SHIFT   (26U)
 
#define SDHC_PROCTL_WECRM(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_PROCTL_WECRM_SHIFT)) & SDHC_PROCTL_WECRM_MASK)
 
SYSCTL - System Control register
#define SDHC_SYSCTL_IPGEN_MASK   (0x1U)
 
#define SDHC_SYSCTL_IPGEN_SHIFT   (0U)
 
#define SDHC_SYSCTL_IPGEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_SYSCTL_IPGEN_SHIFT)) & SDHC_SYSCTL_IPGEN_MASK)
 
#define SDHC_SYSCTL_HCKEN_MASK   (0x2U)
 
#define SDHC_SYSCTL_HCKEN_SHIFT   (1U)
 
#define SDHC_SYSCTL_HCKEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_SYSCTL_HCKEN_SHIFT)) & SDHC_SYSCTL_HCKEN_MASK)
 
#define SDHC_SYSCTL_PEREN_MASK   (0x4U)
 
#define SDHC_SYSCTL_PEREN_SHIFT   (2U)
 
#define SDHC_SYSCTL_PEREN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_SYSCTL_PEREN_SHIFT)) & SDHC_SYSCTL_PEREN_MASK)
 
#define SDHC_SYSCTL_SDCLKEN_MASK   (0x8U)
 
#define SDHC_SYSCTL_SDCLKEN_SHIFT   (3U)
 
#define SDHC_SYSCTL_SDCLKEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_SYSCTL_SDCLKEN_SHIFT)) & SDHC_SYSCTL_SDCLKEN_MASK)
 
#define SDHC_SYSCTL_DVS_MASK   (0xF0U)
 
#define SDHC_SYSCTL_DVS_SHIFT   (4U)
 
#define SDHC_SYSCTL_DVS(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_SYSCTL_DVS_SHIFT)) & SDHC_SYSCTL_DVS_MASK)
 
#define SDHC_SYSCTL_SDCLKFS_MASK   (0xFF00U)
 
#define SDHC_SYSCTL_SDCLKFS_SHIFT   (8U)
 
#define SDHC_SYSCTL_SDCLKFS(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_SYSCTL_SDCLKFS_SHIFT)) & SDHC_SYSCTL_SDCLKFS_MASK)
 
#define SDHC_SYSCTL_DTOCV_MASK   (0xF0000U)
 
#define SDHC_SYSCTL_DTOCV_SHIFT   (16U)
 
#define SDHC_SYSCTL_DTOCV(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_SYSCTL_DTOCV_SHIFT)) & SDHC_SYSCTL_DTOCV_MASK)
 
#define SDHC_SYSCTL_RSTA_MASK   (0x1000000U)
 
#define SDHC_SYSCTL_RSTA_SHIFT   (24U)
 
#define SDHC_SYSCTL_RSTA(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_SYSCTL_RSTA_SHIFT)) & SDHC_SYSCTL_RSTA_MASK)
 
#define SDHC_SYSCTL_RSTC_MASK   (0x2000000U)
 
#define SDHC_SYSCTL_RSTC_SHIFT   (25U)
 
#define SDHC_SYSCTL_RSTC(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_SYSCTL_RSTC_SHIFT)) & SDHC_SYSCTL_RSTC_MASK)
 
#define SDHC_SYSCTL_RSTD_MASK   (0x4000000U)
 
#define SDHC_SYSCTL_RSTD_SHIFT   (26U)
 
#define SDHC_SYSCTL_RSTD(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_SYSCTL_RSTD_SHIFT)) & SDHC_SYSCTL_RSTD_MASK)
 
#define SDHC_SYSCTL_INITA_MASK   (0x8000000U)
 
#define SDHC_SYSCTL_INITA_SHIFT   (27U)
 
#define SDHC_SYSCTL_INITA(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_SYSCTL_INITA_SHIFT)) & SDHC_SYSCTL_INITA_MASK)
 
IRQSTAT - Interrupt Status register
#define SDHC_IRQSTAT_CC_MASK   (0x1U)
 
#define SDHC_IRQSTAT_CC_SHIFT   (0U)
 
#define SDHC_IRQSTAT_CC(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTAT_CC_SHIFT)) & SDHC_IRQSTAT_CC_MASK)
 
#define SDHC_IRQSTAT_TC_MASK   (0x2U)
 
#define SDHC_IRQSTAT_TC_SHIFT   (1U)
 
#define SDHC_IRQSTAT_TC(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTAT_TC_SHIFT)) & SDHC_IRQSTAT_TC_MASK)
 
#define SDHC_IRQSTAT_BGE_MASK   (0x4U)
 
#define SDHC_IRQSTAT_BGE_SHIFT   (2U)
 
#define SDHC_IRQSTAT_BGE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTAT_BGE_SHIFT)) & SDHC_IRQSTAT_BGE_MASK)
 
#define SDHC_IRQSTAT_DINT_MASK   (0x8U)
 
#define SDHC_IRQSTAT_DINT_SHIFT   (3U)
 
#define SDHC_IRQSTAT_DINT(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTAT_DINT_SHIFT)) & SDHC_IRQSTAT_DINT_MASK)
 
#define SDHC_IRQSTAT_BWR_MASK   (0x10U)
 
#define SDHC_IRQSTAT_BWR_SHIFT   (4U)
 
#define SDHC_IRQSTAT_BWR(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTAT_BWR_SHIFT)) & SDHC_IRQSTAT_BWR_MASK)
 
#define SDHC_IRQSTAT_BRR_MASK   (0x20U)
 
#define SDHC_IRQSTAT_BRR_SHIFT   (5U)
 
#define SDHC_IRQSTAT_BRR(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTAT_BRR_SHIFT)) & SDHC_IRQSTAT_BRR_MASK)
 
#define SDHC_IRQSTAT_CINS_MASK   (0x40U)
 
#define SDHC_IRQSTAT_CINS_SHIFT   (6U)
 
#define SDHC_IRQSTAT_CINS(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTAT_CINS_SHIFT)) & SDHC_IRQSTAT_CINS_MASK)
 
#define SDHC_IRQSTAT_CRM_MASK   (0x80U)
 
#define SDHC_IRQSTAT_CRM_SHIFT   (7U)
 
#define SDHC_IRQSTAT_CRM(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTAT_CRM_SHIFT)) & SDHC_IRQSTAT_CRM_MASK)
 
#define SDHC_IRQSTAT_CINT_MASK   (0x100U)
 
#define SDHC_IRQSTAT_CINT_SHIFT   (8U)
 
#define SDHC_IRQSTAT_CINT(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTAT_CINT_SHIFT)) & SDHC_IRQSTAT_CINT_MASK)
 
#define SDHC_IRQSTAT_CTOE_MASK   (0x10000U)
 
#define SDHC_IRQSTAT_CTOE_SHIFT   (16U)
 
#define SDHC_IRQSTAT_CTOE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTAT_CTOE_SHIFT)) & SDHC_IRQSTAT_CTOE_MASK)
 
#define SDHC_IRQSTAT_CCE_MASK   (0x20000U)
 
#define SDHC_IRQSTAT_CCE_SHIFT   (17U)
 
#define SDHC_IRQSTAT_CCE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTAT_CCE_SHIFT)) & SDHC_IRQSTAT_CCE_MASK)
 
#define SDHC_IRQSTAT_CEBE_MASK   (0x40000U)
 
#define SDHC_IRQSTAT_CEBE_SHIFT   (18U)
 
#define SDHC_IRQSTAT_CEBE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTAT_CEBE_SHIFT)) & SDHC_IRQSTAT_CEBE_MASK)
 
#define SDHC_IRQSTAT_CIE_MASK   (0x80000U)
 
#define SDHC_IRQSTAT_CIE_SHIFT   (19U)
 
#define SDHC_IRQSTAT_CIE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTAT_CIE_SHIFT)) & SDHC_IRQSTAT_CIE_MASK)
 
#define SDHC_IRQSTAT_DTOE_MASK   (0x100000U)
 
#define SDHC_IRQSTAT_DTOE_SHIFT   (20U)
 
#define SDHC_IRQSTAT_DTOE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTAT_DTOE_SHIFT)) & SDHC_IRQSTAT_DTOE_MASK)
 
#define SDHC_IRQSTAT_DCE_MASK   (0x200000U)
 
#define SDHC_IRQSTAT_DCE_SHIFT   (21U)
 
#define SDHC_IRQSTAT_DCE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTAT_DCE_SHIFT)) & SDHC_IRQSTAT_DCE_MASK)
 
#define SDHC_IRQSTAT_DEBE_MASK   (0x400000U)
 
#define SDHC_IRQSTAT_DEBE_SHIFT   (22U)
 
#define SDHC_IRQSTAT_DEBE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTAT_DEBE_SHIFT)) & SDHC_IRQSTAT_DEBE_MASK)
 
#define SDHC_IRQSTAT_AC12E_MASK   (0x1000000U)
 
#define SDHC_IRQSTAT_AC12E_SHIFT   (24U)
 
#define SDHC_IRQSTAT_AC12E(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTAT_AC12E_SHIFT)) & SDHC_IRQSTAT_AC12E_MASK)
 
#define SDHC_IRQSTAT_DMAE_MASK   (0x10000000U)
 
#define SDHC_IRQSTAT_DMAE_SHIFT   (28U)
 
#define SDHC_IRQSTAT_DMAE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTAT_DMAE_SHIFT)) & SDHC_IRQSTAT_DMAE_MASK)
 
IRQSTATEN - Interrupt Status Enable register
#define SDHC_IRQSTATEN_CCSEN_MASK   (0x1U)
 
#define SDHC_IRQSTATEN_CCSEN_SHIFT   (0U)
 
#define SDHC_IRQSTATEN_CCSEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTATEN_CCSEN_SHIFT)) & SDHC_IRQSTATEN_CCSEN_MASK)
 
#define SDHC_IRQSTATEN_TCSEN_MASK   (0x2U)
 
#define SDHC_IRQSTATEN_TCSEN_SHIFT   (1U)
 
#define SDHC_IRQSTATEN_TCSEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTATEN_TCSEN_SHIFT)) & SDHC_IRQSTATEN_TCSEN_MASK)
 
#define SDHC_IRQSTATEN_BGESEN_MASK   (0x4U)
 
#define SDHC_IRQSTATEN_BGESEN_SHIFT   (2U)
 
#define SDHC_IRQSTATEN_BGESEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTATEN_BGESEN_SHIFT)) & SDHC_IRQSTATEN_BGESEN_MASK)
 
#define SDHC_IRQSTATEN_DINTSEN_MASK   (0x8U)
 
#define SDHC_IRQSTATEN_DINTSEN_SHIFT   (3U)
 
#define SDHC_IRQSTATEN_DINTSEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTATEN_DINTSEN_SHIFT)) & SDHC_IRQSTATEN_DINTSEN_MASK)
 
#define SDHC_IRQSTATEN_BWRSEN_MASK   (0x10U)
 
#define SDHC_IRQSTATEN_BWRSEN_SHIFT   (4U)
 
#define SDHC_IRQSTATEN_BWRSEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTATEN_BWRSEN_SHIFT)) & SDHC_IRQSTATEN_BWRSEN_MASK)
 
#define SDHC_IRQSTATEN_BRRSEN_MASK   (0x20U)
 
#define SDHC_IRQSTATEN_BRRSEN_SHIFT   (5U)
 
#define SDHC_IRQSTATEN_BRRSEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTATEN_BRRSEN_SHIFT)) & SDHC_IRQSTATEN_BRRSEN_MASK)
 
#define SDHC_IRQSTATEN_CINSEN_MASK   (0x40U)
 
#define SDHC_IRQSTATEN_CINSEN_SHIFT   (6U)
 
#define SDHC_IRQSTATEN_CINSEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTATEN_CINSEN_SHIFT)) & SDHC_IRQSTATEN_CINSEN_MASK)
 
#define SDHC_IRQSTATEN_CRMSEN_MASK   (0x80U)
 
#define SDHC_IRQSTATEN_CRMSEN_SHIFT   (7U)
 
#define SDHC_IRQSTATEN_CRMSEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTATEN_CRMSEN_SHIFT)) & SDHC_IRQSTATEN_CRMSEN_MASK)
 
#define SDHC_IRQSTATEN_CINTSEN_MASK   (0x100U)
 
#define SDHC_IRQSTATEN_CINTSEN_SHIFT   (8U)
 
#define SDHC_IRQSTATEN_CINTSEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTATEN_CINTSEN_SHIFT)) & SDHC_IRQSTATEN_CINTSEN_MASK)
 
#define SDHC_IRQSTATEN_CTOESEN_MASK   (0x10000U)
 
#define SDHC_IRQSTATEN_CTOESEN_SHIFT   (16U)
 
#define SDHC_IRQSTATEN_CTOESEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTATEN_CTOESEN_SHIFT)) & SDHC_IRQSTATEN_CTOESEN_MASK)
 
#define SDHC_IRQSTATEN_CCESEN_MASK   (0x20000U)
 
#define SDHC_IRQSTATEN_CCESEN_SHIFT   (17U)
 
#define SDHC_IRQSTATEN_CCESEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTATEN_CCESEN_SHIFT)) & SDHC_IRQSTATEN_CCESEN_MASK)
 
#define SDHC_IRQSTATEN_CEBESEN_MASK   (0x40000U)
 
#define SDHC_IRQSTATEN_CEBESEN_SHIFT   (18U)
 
#define SDHC_IRQSTATEN_CEBESEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTATEN_CEBESEN_SHIFT)) & SDHC_IRQSTATEN_CEBESEN_MASK)
 
#define SDHC_IRQSTATEN_CIESEN_MASK   (0x80000U)
 
#define SDHC_IRQSTATEN_CIESEN_SHIFT   (19U)
 
#define SDHC_IRQSTATEN_CIESEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTATEN_CIESEN_SHIFT)) & SDHC_IRQSTATEN_CIESEN_MASK)
 
#define SDHC_IRQSTATEN_DTOESEN_MASK   (0x100000U)
 
#define SDHC_IRQSTATEN_DTOESEN_SHIFT   (20U)
 
#define SDHC_IRQSTATEN_DTOESEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTATEN_DTOESEN_SHIFT)) & SDHC_IRQSTATEN_DTOESEN_MASK)
 
#define SDHC_IRQSTATEN_DCESEN_MASK   (0x200000U)
 
#define SDHC_IRQSTATEN_DCESEN_SHIFT   (21U)
 
#define SDHC_IRQSTATEN_DCESEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTATEN_DCESEN_SHIFT)) & SDHC_IRQSTATEN_DCESEN_MASK)
 
#define SDHC_IRQSTATEN_DEBESEN_MASK   (0x400000U)
 
#define SDHC_IRQSTATEN_DEBESEN_SHIFT   (22U)
 
#define SDHC_IRQSTATEN_DEBESEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTATEN_DEBESEN_SHIFT)) & SDHC_IRQSTATEN_DEBESEN_MASK)
 
#define SDHC_IRQSTATEN_AC12ESEN_MASK   (0x1000000U)
 
#define SDHC_IRQSTATEN_AC12ESEN_SHIFT   (24U)
 
#define SDHC_IRQSTATEN_AC12ESEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTATEN_AC12ESEN_SHIFT)) & SDHC_IRQSTATEN_AC12ESEN_MASK)
 
#define SDHC_IRQSTATEN_DMAESEN_MASK   (0x10000000U)
 
#define SDHC_IRQSTATEN_DMAESEN_SHIFT   (28U)
 
#define SDHC_IRQSTATEN_DMAESEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSTATEN_DMAESEN_SHIFT)) & SDHC_IRQSTATEN_DMAESEN_MASK)
 
IRQSIGEN - Interrupt Signal Enable register
#define SDHC_IRQSIGEN_CCIEN_MASK   (0x1U)
 
#define SDHC_IRQSIGEN_CCIEN_SHIFT   (0U)
 
#define SDHC_IRQSIGEN_CCIEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSIGEN_CCIEN_SHIFT)) & SDHC_IRQSIGEN_CCIEN_MASK)
 
#define SDHC_IRQSIGEN_TCIEN_MASK   (0x2U)
 
#define SDHC_IRQSIGEN_TCIEN_SHIFT   (1U)
 
#define SDHC_IRQSIGEN_TCIEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSIGEN_TCIEN_SHIFT)) & SDHC_IRQSIGEN_TCIEN_MASK)
 
#define SDHC_IRQSIGEN_BGEIEN_MASK   (0x4U)
 
#define SDHC_IRQSIGEN_BGEIEN_SHIFT   (2U)
 
#define SDHC_IRQSIGEN_BGEIEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSIGEN_BGEIEN_SHIFT)) & SDHC_IRQSIGEN_BGEIEN_MASK)
 
#define SDHC_IRQSIGEN_DINTIEN_MASK   (0x8U)
 
#define SDHC_IRQSIGEN_DINTIEN_SHIFT   (3U)
 
#define SDHC_IRQSIGEN_DINTIEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSIGEN_DINTIEN_SHIFT)) & SDHC_IRQSIGEN_DINTIEN_MASK)
 
#define SDHC_IRQSIGEN_BWRIEN_MASK   (0x10U)
 
#define SDHC_IRQSIGEN_BWRIEN_SHIFT   (4U)
 
#define SDHC_IRQSIGEN_BWRIEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSIGEN_BWRIEN_SHIFT)) & SDHC_IRQSIGEN_BWRIEN_MASK)
 
#define SDHC_IRQSIGEN_BRRIEN_MASK   (0x20U)
 
#define SDHC_IRQSIGEN_BRRIEN_SHIFT   (5U)
 
#define SDHC_IRQSIGEN_BRRIEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSIGEN_BRRIEN_SHIFT)) & SDHC_IRQSIGEN_BRRIEN_MASK)
 
#define SDHC_IRQSIGEN_CINSIEN_MASK   (0x40U)
 
#define SDHC_IRQSIGEN_CINSIEN_SHIFT   (6U)
 
#define SDHC_IRQSIGEN_CINSIEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSIGEN_CINSIEN_SHIFT)) & SDHC_IRQSIGEN_CINSIEN_MASK)
 
#define SDHC_IRQSIGEN_CRMIEN_MASK   (0x80U)
 
#define SDHC_IRQSIGEN_CRMIEN_SHIFT   (7U)
 
#define SDHC_IRQSIGEN_CRMIEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSIGEN_CRMIEN_SHIFT)) & SDHC_IRQSIGEN_CRMIEN_MASK)
 
#define SDHC_IRQSIGEN_CINTIEN_MASK   (0x100U)
 
#define SDHC_IRQSIGEN_CINTIEN_SHIFT   (8U)
 
#define SDHC_IRQSIGEN_CINTIEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSIGEN_CINTIEN_SHIFT)) & SDHC_IRQSIGEN_CINTIEN_MASK)
 
#define SDHC_IRQSIGEN_CTOEIEN_MASK   (0x10000U)
 
#define SDHC_IRQSIGEN_CTOEIEN_SHIFT   (16U)
 
#define SDHC_IRQSIGEN_CTOEIEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSIGEN_CTOEIEN_SHIFT)) & SDHC_IRQSIGEN_CTOEIEN_MASK)
 
#define SDHC_IRQSIGEN_CCEIEN_MASK   (0x20000U)
 
#define SDHC_IRQSIGEN_CCEIEN_SHIFT   (17U)
 
#define SDHC_IRQSIGEN_CCEIEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSIGEN_CCEIEN_SHIFT)) & SDHC_IRQSIGEN_CCEIEN_MASK)
 
#define SDHC_IRQSIGEN_CEBEIEN_MASK   (0x40000U)
 
#define SDHC_IRQSIGEN_CEBEIEN_SHIFT   (18U)
 
#define SDHC_IRQSIGEN_CEBEIEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSIGEN_CEBEIEN_SHIFT)) & SDHC_IRQSIGEN_CEBEIEN_MASK)
 
#define SDHC_IRQSIGEN_CIEIEN_MASK   (0x80000U)
 
#define SDHC_IRQSIGEN_CIEIEN_SHIFT   (19U)
 
#define SDHC_IRQSIGEN_CIEIEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSIGEN_CIEIEN_SHIFT)) & SDHC_IRQSIGEN_CIEIEN_MASK)
 
#define SDHC_IRQSIGEN_DTOEIEN_MASK   (0x100000U)
 
#define SDHC_IRQSIGEN_DTOEIEN_SHIFT   (20U)
 
#define SDHC_IRQSIGEN_DTOEIEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSIGEN_DTOEIEN_SHIFT)) & SDHC_IRQSIGEN_DTOEIEN_MASK)
 
#define SDHC_IRQSIGEN_DCEIEN_MASK   (0x200000U)
 
#define SDHC_IRQSIGEN_DCEIEN_SHIFT   (21U)
 
#define SDHC_IRQSIGEN_DCEIEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSIGEN_DCEIEN_SHIFT)) & SDHC_IRQSIGEN_DCEIEN_MASK)
 
#define SDHC_IRQSIGEN_DEBEIEN_MASK   (0x400000U)
 
#define SDHC_IRQSIGEN_DEBEIEN_SHIFT   (22U)
 
#define SDHC_IRQSIGEN_DEBEIEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSIGEN_DEBEIEN_SHIFT)) & SDHC_IRQSIGEN_DEBEIEN_MASK)
 
#define SDHC_IRQSIGEN_AC12EIEN_MASK   (0x1000000U)
 
#define SDHC_IRQSIGEN_AC12EIEN_SHIFT   (24U)
 
#define SDHC_IRQSIGEN_AC12EIEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSIGEN_AC12EIEN_SHIFT)) & SDHC_IRQSIGEN_AC12EIEN_MASK)
 
#define SDHC_IRQSIGEN_DMAEIEN_MASK   (0x10000000U)
 
#define SDHC_IRQSIGEN_DMAEIEN_SHIFT   (28U)
 
#define SDHC_IRQSIGEN_DMAEIEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_IRQSIGEN_DMAEIEN_SHIFT)) & SDHC_IRQSIGEN_DMAEIEN_MASK)
 
AC12ERR - Auto CMD12 Error Status Register
#define SDHC_AC12ERR_AC12NE_MASK   (0x1U)
 
#define SDHC_AC12ERR_AC12NE_SHIFT   (0U)
 
#define SDHC_AC12ERR_AC12NE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_AC12ERR_AC12NE_SHIFT)) & SDHC_AC12ERR_AC12NE_MASK)
 
#define SDHC_AC12ERR_AC12TOE_MASK   (0x2U)
 
#define SDHC_AC12ERR_AC12TOE_SHIFT   (1U)
 
#define SDHC_AC12ERR_AC12TOE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_AC12ERR_AC12TOE_SHIFT)) & SDHC_AC12ERR_AC12TOE_MASK)
 
#define SDHC_AC12ERR_AC12EBE_MASK   (0x4U)
 
#define SDHC_AC12ERR_AC12EBE_SHIFT   (2U)
 
#define SDHC_AC12ERR_AC12EBE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_AC12ERR_AC12EBE_SHIFT)) & SDHC_AC12ERR_AC12EBE_MASK)
 
#define SDHC_AC12ERR_AC12CE_MASK   (0x8U)
 
#define SDHC_AC12ERR_AC12CE_SHIFT   (3U)
 
#define SDHC_AC12ERR_AC12CE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_AC12ERR_AC12CE_SHIFT)) & SDHC_AC12ERR_AC12CE_MASK)
 
#define SDHC_AC12ERR_AC12IE_MASK   (0x10U)
 
#define SDHC_AC12ERR_AC12IE_SHIFT   (4U)
 
#define SDHC_AC12ERR_AC12IE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_AC12ERR_AC12IE_SHIFT)) & SDHC_AC12ERR_AC12IE_MASK)
 
#define SDHC_AC12ERR_CNIBAC12E_MASK   (0x80U)
 
#define SDHC_AC12ERR_CNIBAC12E_SHIFT   (7U)
 
#define SDHC_AC12ERR_CNIBAC12E(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_AC12ERR_CNIBAC12E_SHIFT)) & SDHC_AC12ERR_CNIBAC12E_MASK)
 
HTCAPBLT - Host Controller Capabilities
#define SDHC_HTCAPBLT_MBL_MASK   (0x70000U)
 
#define SDHC_HTCAPBLT_MBL_SHIFT   (16U)
 
#define SDHC_HTCAPBLT_MBL(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_HTCAPBLT_MBL_SHIFT)) & SDHC_HTCAPBLT_MBL_MASK)
 
#define SDHC_HTCAPBLT_ADMAS_MASK   (0x100000U)
 
#define SDHC_HTCAPBLT_ADMAS_SHIFT   (20U)
 
#define SDHC_HTCAPBLT_ADMAS(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_HTCAPBLT_ADMAS_SHIFT)) & SDHC_HTCAPBLT_ADMAS_MASK)
 
#define SDHC_HTCAPBLT_HSS_MASK   (0x200000U)
 
#define SDHC_HTCAPBLT_HSS_SHIFT   (21U)
 
#define SDHC_HTCAPBLT_HSS(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_HTCAPBLT_HSS_SHIFT)) & SDHC_HTCAPBLT_HSS_MASK)
 
#define SDHC_HTCAPBLT_DMAS_MASK   (0x400000U)
 
#define SDHC_HTCAPBLT_DMAS_SHIFT   (22U)
 
#define SDHC_HTCAPBLT_DMAS(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_HTCAPBLT_DMAS_SHIFT)) & SDHC_HTCAPBLT_DMAS_MASK)
 
#define SDHC_HTCAPBLT_SRS_MASK   (0x800000U)
 
#define SDHC_HTCAPBLT_SRS_SHIFT   (23U)
 
#define SDHC_HTCAPBLT_SRS(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_HTCAPBLT_SRS_SHIFT)) & SDHC_HTCAPBLT_SRS_MASK)
 
#define SDHC_HTCAPBLT_VS33_MASK   (0x1000000U)
 
#define SDHC_HTCAPBLT_VS33_SHIFT   (24U)
 
#define SDHC_HTCAPBLT_VS33(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_HTCAPBLT_VS33_SHIFT)) & SDHC_HTCAPBLT_VS33_MASK)
 
WML - Watermark Level Register
#define SDHC_WML_RDWML_MASK   (0xFFU)
 
#define SDHC_WML_RDWML_SHIFT   (0U)
 
#define SDHC_WML_RDWML(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_WML_RDWML_SHIFT)) & SDHC_WML_RDWML_MASK)
 
#define SDHC_WML_WRWML_MASK   (0xFF0000U)
 
#define SDHC_WML_WRWML_SHIFT   (16U)
 
#define SDHC_WML_WRWML(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_WML_WRWML_SHIFT)) & SDHC_WML_WRWML_MASK)
 
FEVT - Force Event register
#define SDHC_FEVT_AC12NE_MASK   (0x1U)
 
#define SDHC_FEVT_AC12NE_SHIFT   (0U)
 
#define SDHC_FEVT_AC12NE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_FEVT_AC12NE_SHIFT)) & SDHC_FEVT_AC12NE_MASK)
 
#define SDHC_FEVT_AC12TOE_MASK   (0x2U)
 
#define SDHC_FEVT_AC12TOE_SHIFT   (1U)
 
#define SDHC_FEVT_AC12TOE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_FEVT_AC12TOE_SHIFT)) & SDHC_FEVT_AC12TOE_MASK)
 
#define SDHC_FEVT_AC12CE_MASK   (0x4U)
 
#define SDHC_FEVT_AC12CE_SHIFT   (2U)
 
#define SDHC_FEVT_AC12CE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_FEVT_AC12CE_SHIFT)) & SDHC_FEVT_AC12CE_MASK)
 
#define SDHC_FEVT_AC12EBE_MASK   (0x8U)
 
#define SDHC_FEVT_AC12EBE_SHIFT   (3U)
 
#define SDHC_FEVT_AC12EBE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_FEVT_AC12EBE_SHIFT)) & SDHC_FEVT_AC12EBE_MASK)
 
#define SDHC_FEVT_AC12IE_MASK   (0x10U)
 
#define SDHC_FEVT_AC12IE_SHIFT   (4U)
 
#define SDHC_FEVT_AC12IE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_FEVT_AC12IE_SHIFT)) & SDHC_FEVT_AC12IE_MASK)
 
#define SDHC_FEVT_CNIBAC12E_MASK   (0x80U)
 
#define SDHC_FEVT_CNIBAC12E_SHIFT   (7U)
 
#define SDHC_FEVT_CNIBAC12E(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_FEVT_CNIBAC12E_SHIFT)) & SDHC_FEVT_CNIBAC12E_MASK)
 
#define SDHC_FEVT_CTOE_MASK   (0x10000U)
 
#define SDHC_FEVT_CTOE_SHIFT   (16U)
 
#define SDHC_FEVT_CTOE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_FEVT_CTOE_SHIFT)) & SDHC_FEVT_CTOE_MASK)
 
#define SDHC_FEVT_CCE_MASK   (0x20000U)
 
#define SDHC_FEVT_CCE_SHIFT   (17U)
 
#define SDHC_FEVT_CCE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_FEVT_CCE_SHIFT)) & SDHC_FEVT_CCE_MASK)
 
#define SDHC_FEVT_CEBE_MASK   (0x40000U)
 
#define SDHC_FEVT_CEBE_SHIFT   (18U)
 
#define SDHC_FEVT_CEBE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_FEVT_CEBE_SHIFT)) & SDHC_FEVT_CEBE_MASK)
 
#define SDHC_FEVT_CIE_MASK   (0x80000U)
 
#define SDHC_FEVT_CIE_SHIFT   (19U)
 
#define SDHC_FEVT_CIE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_FEVT_CIE_SHIFT)) & SDHC_FEVT_CIE_MASK)
 
#define SDHC_FEVT_DTOE_MASK   (0x100000U)
 
#define SDHC_FEVT_DTOE_SHIFT   (20U)
 
#define SDHC_FEVT_DTOE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_FEVT_DTOE_SHIFT)) & SDHC_FEVT_DTOE_MASK)
 
#define SDHC_FEVT_DCE_MASK   (0x200000U)
 
#define SDHC_FEVT_DCE_SHIFT   (21U)
 
#define SDHC_FEVT_DCE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_FEVT_DCE_SHIFT)) & SDHC_FEVT_DCE_MASK)
 
#define SDHC_FEVT_DEBE_MASK   (0x400000U)
 
#define SDHC_FEVT_DEBE_SHIFT   (22U)
 
#define SDHC_FEVT_DEBE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_FEVT_DEBE_SHIFT)) & SDHC_FEVT_DEBE_MASK)
 
#define SDHC_FEVT_AC12E_MASK   (0x1000000U)
 
#define SDHC_FEVT_AC12E_SHIFT   (24U)
 
#define SDHC_FEVT_AC12E(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_FEVT_AC12E_SHIFT)) & SDHC_FEVT_AC12E_MASK)
 
#define SDHC_FEVT_DMAE_MASK   (0x10000000U)
 
#define SDHC_FEVT_DMAE_SHIFT   (28U)
 
#define SDHC_FEVT_DMAE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_FEVT_DMAE_SHIFT)) & SDHC_FEVT_DMAE_MASK)
 
#define SDHC_FEVT_CINT_MASK   (0x80000000U)
 
#define SDHC_FEVT_CINT_SHIFT   (31U)
 
#define SDHC_FEVT_CINT(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_FEVT_CINT_SHIFT)) & SDHC_FEVT_CINT_MASK)
 
ADMAES - ADMA Error Status register
#define SDHC_ADMAES_ADMAES_MASK   (0x3U)
 
#define SDHC_ADMAES_ADMAES_SHIFT   (0U)
 
#define SDHC_ADMAES_ADMAES(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_ADMAES_ADMAES_SHIFT)) & SDHC_ADMAES_ADMAES_MASK)
 
#define SDHC_ADMAES_ADMALME_MASK   (0x4U)
 
#define SDHC_ADMAES_ADMALME_SHIFT   (2U)
 
#define SDHC_ADMAES_ADMALME(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_ADMAES_ADMALME_SHIFT)) & SDHC_ADMAES_ADMALME_MASK)
 
#define SDHC_ADMAES_ADMADCE_MASK   (0x8U)
 
#define SDHC_ADMAES_ADMADCE_SHIFT   (3U)
 
#define SDHC_ADMAES_ADMADCE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_ADMAES_ADMADCE_SHIFT)) & SDHC_ADMAES_ADMADCE_MASK)
 
ADSADDR - ADMA System Addressregister
#define SDHC_ADSADDR_ADSADDR_MASK   (0xFFFFFFFCU)
 
#define SDHC_ADSADDR_ADSADDR_SHIFT   (2U)
 
#define SDHC_ADSADDR_ADSADDR(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_ADSADDR_ADSADDR_SHIFT)) & SDHC_ADSADDR_ADSADDR_MASK)
 
VENDOR - Vendor Specific register
#define SDHC_VENDOR_EXTDMAEN_MASK   (0x1U)
 
#define SDHC_VENDOR_EXTDMAEN_SHIFT   (0U)
 
#define SDHC_VENDOR_EXTDMAEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_VENDOR_EXTDMAEN_SHIFT)) & SDHC_VENDOR_EXTDMAEN_MASK)
 
#define SDHC_VENDOR_EXBLKNU_MASK   (0x2U)
 
#define SDHC_VENDOR_EXBLKNU_SHIFT   (1U)
 
#define SDHC_VENDOR_EXBLKNU(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_VENDOR_EXBLKNU_SHIFT)) & SDHC_VENDOR_EXBLKNU_MASK)
 
#define SDHC_VENDOR_INTSTVAL_MASK   (0xFF0000U)
 
#define SDHC_VENDOR_INTSTVAL_SHIFT   (16U)
 
#define SDHC_VENDOR_INTSTVAL(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_VENDOR_INTSTVAL_SHIFT)) & SDHC_VENDOR_INTSTVAL_MASK)
 
MMCBOOT - MMC Boot register
#define SDHC_MMCBOOT_DTOCVACK_MASK   (0xFU)
 
#define SDHC_MMCBOOT_DTOCVACK_SHIFT   (0U)
 
#define SDHC_MMCBOOT_DTOCVACK(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_MMCBOOT_DTOCVACK_SHIFT)) & SDHC_MMCBOOT_DTOCVACK_MASK)
 
#define SDHC_MMCBOOT_BOOTACK_MASK   (0x10U)
 
#define SDHC_MMCBOOT_BOOTACK_SHIFT   (4U)
 
#define SDHC_MMCBOOT_BOOTACK(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_MMCBOOT_BOOTACK_SHIFT)) & SDHC_MMCBOOT_BOOTACK_MASK)
 
#define SDHC_MMCBOOT_BOOTMODE_MASK   (0x20U)
 
#define SDHC_MMCBOOT_BOOTMODE_SHIFT   (5U)
 
#define SDHC_MMCBOOT_BOOTMODE(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_MMCBOOT_BOOTMODE_SHIFT)) & SDHC_MMCBOOT_BOOTMODE_MASK)
 
#define SDHC_MMCBOOT_BOOTEN_MASK   (0x40U)
 
#define SDHC_MMCBOOT_BOOTEN_SHIFT   (6U)
 
#define SDHC_MMCBOOT_BOOTEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_MMCBOOT_BOOTEN_SHIFT)) & SDHC_MMCBOOT_BOOTEN_MASK)
 
#define SDHC_MMCBOOT_AUTOSABGEN_MASK   (0x80U)
 
#define SDHC_MMCBOOT_AUTOSABGEN_SHIFT   (7U)
 
#define SDHC_MMCBOOT_AUTOSABGEN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_MMCBOOT_AUTOSABGEN_SHIFT)) & SDHC_MMCBOOT_AUTOSABGEN_MASK)
 
#define SDHC_MMCBOOT_BOOTBLKCNT_MASK   (0xFFFF0000U)
 
#define SDHC_MMCBOOT_BOOTBLKCNT_SHIFT   (16U)
 
#define SDHC_MMCBOOT_BOOTBLKCNT(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_MMCBOOT_BOOTBLKCNT_SHIFT)) & SDHC_MMCBOOT_BOOTBLKCNT_MASK)
 
HOSTVER - Host Controller Version
#define SDHC_HOSTVER_SVN_MASK   (0xFFU)
 
#define SDHC_HOSTVER_SVN_SHIFT   (0U)
 
#define SDHC_HOSTVER_SVN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_HOSTVER_SVN_SHIFT)) & SDHC_HOSTVER_SVN_MASK)
 
#define SDHC_HOSTVER_VVN_MASK   (0xFF00U)
 
#define SDHC_HOSTVER_VVN_SHIFT   (8U)
 
#define SDHC_HOSTVER_VVN(x)   (((uint32_t)(((uint32_t)(x)) << SDHC_HOSTVER_VVN_SHIFT)) & SDHC_HOSTVER_VVN_MASK)
 
SOPT1 - System Options Register 1
#define SIM_SOPT1_RAMSIZE_MASK   (0xF000U)
 
#define SIM_SOPT1_RAMSIZE_SHIFT   (12U)
 
#define SIM_SOPT1_RAMSIZE(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT1_RAMSIZE_SHIFT)) & SIM_SOPT1_RAMSIZE_MASK)
 
#define SIM_SOPT1_OSC32KSEL_MASK   (0xC0000U)
 
#define SIM_SOPT1_OSC32KSEL_SHIFT   (18U)
 
#define SIM_SOPT1_OSC32KSEL(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT1_OSC32KSEL_SHIFT)) & SIM_SOPT1_OSC32KSEL_MASK)
 
#define SIM_SOPT1_USBVSTBY_MASK   (0x20000000U)
 
#define SIM_SOPT1_USBVSTBY_SHIFT   (29U)
 
#define SIM_SOPT1_USBVSTBY(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT1_USBVSTBY_SHIFT)) & SIM_SOPT1_USBVSTBY_MASK)
 
#define SIM_SOPT1_USBSSTBY_MASK   (0x40000000U)
 
#define SIM_SOPT1_USBSSTBY_SHIFT   (30U)
 
#define SIM_SOPT1_USBSSTBY(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT1_USBSSTBY_SHIFT)) & SIM_SOPT1_USBSSTBY_MASK)
 
#define SIM_SOPT1_USBREGEN_MASK   (0x80000000U)
 
#define SIM_SOPT1_USBREGEN_SHIFT   (31U)
 
#define SIM_SOPT1_USBREGEN(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT1_USBREGEN_SHIFT)) & SIM_SOPT1_USBREGEN_MASK)
 
SOPT1CFG - SOPT1 Configuration Register
#define SIM_SOPT1CFG_URWE_MASK   (0x1000000U)
 
#define SIM_SOPT1CFG_URWE_SHIFT   (24U)
 
#define SIM_SOPT1CFG_URWE(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT1CFG_URWE_SHIFT)) & SIM_SOPT1CFG_URWE_MASK)
 
#define SIM_SOPT1CFG_UVSWE_MASK   (0x2000000U)
 
#define SIM_SOPT1CFG_UVSWE_SHIFT   (25U)
 
#define SIM_SOPT1CFG_UVSWE(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT1CFG_UVSWE_SHIFT)) & SIM_SOPT1CFG_UVSWE_MASK)
 
#define SIM_SOPT1CFG_USSWE_MASK   (0x4000000U)
 
#define SIM_SOPT1CFG_USSWE_SHIFT   (26U)
 
#define SIM_SOPT1CFG_USSWE(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT1CFG_USSWE_SHIFT)) & SIM_SOPT1CFG_USSWE_MASK)
 
SOPT2 - System Options Register 2
#define SIM_SOPT2_RTCCLKOUTSEL_MASK   (0x10U)
 
#define SIM_SOPT2_RTCCLKOUTSEL_SHIFT   (4U)
 
#define SIM_SOPT2_RTCCLKOUTSEL(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT2_RTCCLKOUTSEL_SHIFT)) & SIM_SOPT2_RTCCLKOUTSEL_MASK)
 
#define SIM_SOPT2_CLKOUTSEL_MASK   (0xE0U)
 
#define SIM_SOPT2_CLKOUTSEL_SHIFT   (5U)
 
#define SIM_SOPT2_CLKOUTSEL(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT2_CLKOUTSEL_SHIFT)) & SIM_SOPT2_CLKOUTSEL_MASK)
 
#define SIM_SOPT2_FBSL_MASK   (0x300U)
 
#define SIM_SOPT2_FBSL_SHIFT   (8U)
 
#define SIM_SOPT2_FBSL(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT2_FBSL_SHIFT)) & SIM_SOPT2_FBSL_MASK)
 
#define SIM_SOPT2_PTD7PAD_MASK   (0x800U)
 
#define SIM_SOPT2_PTD7PAD_SHIFT   (11U)
 
#define SIM_SOPT2_PTD7PAD(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT2_PTD7PAD_SHIFT)) & SIM_SOPT2_PTD7PAD_MASK)
 
#define SIM_SOPT2_TRACECLKSEL_MASK   (0x1000U)
 
#define SIM_SOPT2_TRACECLKSEL_SHIFT   (12U)
 
#define SIM_SOPT2_TRACECLKSEL(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT2_TRACECLKSEL_SHIFT)) & SIM_SOPT2_TRACECLKSEL_MASK)
 
#define SIM_SOPT2_PLLFLLSEL_MASK   (0x30000U)
 
#define SIM_SOPT2_PLLFLLSEL_SHIFT   (16U)
 
#define SIM_SOPT2_PLLFLLSEL(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT2_PLLFLLSEL_SHIFT)) & SIM_SOPT2_PLLFLLSEL_MASK)
 
#define SIM_SOPT2_USBSRC_MASK   (0x40000U)
 
#define SIM_SOPT2_USBSRC_SHIFT   (18U)
 
#define SIM_SOPT2_USBSRC(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT2_USBSRC_SHIFT)) & SIM_SOPT2_USBSRC_MASK)
 
#define SIM_SOPT2_RMIISRC_MASK   (0x80000U)
 
#define SIM_SOPT2_RMIISRC_SHIFT   (19U)
 
#define SIM_SOPT2_RMIISRC(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT2_RMIISRC_SHIFT)) & SIM_SOPT2_RMIISRC_MASK)
 
#define SIM_SOPT2_TIMESRC_MASK   (0x300000U)
 
#define SIM_SOPT2_TIMESRC_SHIFT   (20U)
 
#define SIM_SOPT2_TIMESRC(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT2_TIMESRC_SHIFT)) & SIM_SOPT2_TIMESRC_MASK)
 
#define SIM_SOPT2_SDHCSRC_MASK   (0x30000000U)
 
#define SIM_SOPT2_SDHCSRC_SHIFT   (28U)
 
#define SIM_SOPT2_SDHCSRC(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT2_SDHCSRC_SHIFT)) & SIM_SOPT2_SDHCSRC_MASK)
 
SOPT4 - System Options Register 4
#define SIM_SOPT4_FTM0FLT0_MASK   (0x1U)
 
#define SIM_SOPT4_FTM0FLT0_SHIFT   (0U)
 
#define SIM_SOPT4_FTM0FLT0(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT4_FTM0FLT0_SHIFT)) & SIM_SOPT4_FTM0FLT0_MASK)
 
#define SIM_SOPT4_FTM0FLT1_MASK   (0x2U)
 
#define SIM_SOPT4_FTM0FLT1_SHIFT   (1U)
 
#define SIM_SOPT4_FTM0FLT1(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT4_FTM0FLT1_SHIFT)) & SIM_SOPT4_FTM0FLT1_MASK)
 
#define SIM_SOPT4_FTM0FLT2_MASK   (0x4U)
 
#define SIM_SOPT4_FTM0FLT2_SHIFT   (2U)
 
#define SIM_SOPT4_FTM0FLT2(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT4_FTM0FLT2_SHIFT)) & SIM_SOPT4_FTM0FLT2_MASK)
 
#define SIM_SOPT4_FTM1FLT0_MASK   (0x10U)
 
#define SIM_SOPT4_FTM1FLT0_SHIFT   (4U)
 
#define SIM_SOPT4_FTM1FLT0(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT4_FTM1FLT0_SHIFT)) & SIM_SOPT4_FTM1FLT0_MASK)
 
#define SIM_SOPT4_FTM2FLT0_MASK   (0x100U)
 
#define SIM_SOPT4_FTM2FLT0_SHIFT   (8U)
 
#define SIM_SOPT4_FTM2FLT0(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT4_FTM2FLT0_SHIFT)) & SIM_SOPT4_FTM2FLT0_MASK)
 
#define SIM_SOPT4_FTM3FLT0_MASK   (0x1000U)
 
#define SIM_SOPT4_FTM3FLT0_SHIFT   (12U)
 
#define SIM_SOPT4_FTM3FLT0(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT4_FTM3FLT0_SHIFT)) & SIM_SOPT4_FTM3FLT0_MASK)
 
#define SIM_SOPT4_FTM1CH0SRC_MASK   (0xC0000U)
 
#define SIM_SOPT4_FTM1CH0SRC_SHIFT   (18U)
 
#define SIM_SOPT4_FTM1CH0SRC(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT4_FTM1CH0SRC_SHIFT)) & SIM_SOPT4_FTM1CH0SRC_MASK)
 
#define SIM_SOPT4_FTM2CH0SRC_MASK   (0x300000U)
 
#define SIM_SOPT4_FTM2CH0SRC_SHIFT   (20U)
 
#define SIM_SOPT4_FTM2CH0SRC(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT4_FTM2CH0SRC_SHIFT)) & SIM_SOPT4_FTM2CH0SRC_MASK)
 
#define SIM_SOPT4_FTM0CLKSEL_MASK   (0x1000000U)
 
#define SIM_SOPT4_FTM0CLKSEL_SHIFT   (24U)
 
#define SIM_SOPT4_FTM0CLKSEL(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT4_FTM0CLKSEL_SHIFT)) & SIM_SOPT4_FTM0CLKSEL_MASK)
 
#define SIM_SOPT4_FTM1CLKSEL_MASK   (0x2000000U)
 
#define SIM_SOPT4_FTM1CLKSEL_SHIFT   (25U)
 
#define SIM_SOPT4_FTM1CLKSEL(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT4_FTM1CLKSEL_SHIFT)) & SIM_SOPT4_FTM1CLKSEL_MASK)
 
#define SIM_SOPT4_FTM2CLKSEL_MASK   (0x4000000U)
 
#define SIM_SOPT4_FTM2CLKSEL_SHIFT   (26U)
 
#define SIM_SOPT4_FTM2CLKSEL(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT4_FTM2CLKSEL_SHIFT)) & SIM_SOPT4_FTM2CLKSEL_MASK)
 
#define SIM_SOPT4_FTM3CLKSEL_MASK   (0x8000000U)
 
#define SIM_SOPT4_FTM3CLKSEL_SHIFT   (27U)
 
#define SIM_SOPT4_FTM3CLKSEL(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT4_FTM3CLKSEL_SHIFT)) & SIM_SOPT4_FTM3CLKSEL_MASK)
 
#define SIM_SOPT4_FTM0TRG0SRC_MASK   (0x10000000U)
 
#define SIM_SOPT4_FTM0TRG0SRC_SHIFT   (28U)
 
#define SIM_SOPT4_FTM0TRG0SRC(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT4_FTM0TRG0SRC_SHIFT)) & SIM_SOPT4_FTM0TRG0SRC_MASK)
 
#define SIM_SOPT4_FTM0TRG1SRC_MASK   (0x20000000U)
 
#define SIM_SOPT4_FTM0TRG1SRC_SHIFT   (29U)
 
#define SIM_SOPT4_FTM0TRG1SRC(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT4_FTM0TRG1SRC_SHIFT)) & SIM_SOPT4_FTM0TRG1SRC_MASK)
 
#define SIM_SOPT4_FTM3TRG0SRC_MASK   (0x40000000U)
 
#define SIM_SOPT4_FTM3TRG0SRC_SHIFT   (30U)
 
#define SIM_SOPT4_FTM3TRG0SRC(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT4_FTM3TRG0SRC_SHIFT)) & SIM_SOPT4_FTM3TRG0SRC_MASK)
 
#define SIM_SOPT4_FTM3TRG1SRC_MASK   (0x80000000U)
 
#define SIM_SOPT4_FTM3TRG1SRC_SHIFT   (31U)
 
#define SIM_SOPT4_FTM3TRG1SRC(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT4_FTM3TRG1SRC_SHIFT)) & SIM_SOPT4_FTM3TRG1SRC_MASK)
 
SOPT5 - System Options Register 5
#define SIM_SOPT5_UART0TXSRC_MASK   (0x3U)
 
#define SIM_SOPT5_UART0TXSRC_SHIFT   (0U)
 
#define SIM_SOPT5_UART0TXSRC(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT5_UART0TXSRC_SHIFT)) & SIM_SOPT5_UART0TXSRC_MASK)
 
#define SIM_SOPT5_UART0RXSRC_MASK   (0xCU)
 
#define SIM_SOPT5_UART0RXSRC_SHIFT   (2U)
 
#define SIM_SOPT5_UART0RXSRC(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT5_UART0RXSRC_SHIFT)) & SIM_SOPT5_UART0RXSRC_MASK)
 
#define SIM_SOPT5_UART1TXSRC_MASK   (0x30U)
 
#define SIM_SOPT5_UART1TXSRC_SHIFT   (4U)
 
#define SIM_SOPT5_UART1TXSRC(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT5_UART1TXSRC_SHIFT)) & SIM_SOPT5_UART1TXSRC_MASK)
 
#define SIM_SOPT5_UART1RXSRC_MASK   (0xC0U)
 
#define SIM_SOPT5_UART1RXSRC_SHIFT   (6U)
 
#define SIM_SOPT5_UART1RXSRC(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT5_UART1RXSRC_SHIFT)) & SIM_SOPT5_UART1RXSRC_MASK)
 
SOPT7 - System Options Register 7
#define SIM_SOPT7_ADC0TRGSEL_MASK   (0xFU)
 
#define SIM_SOPT7_ADC0TRGSEL_SHIFT   (0U)
 
#define SIM_SOPT7_ADC0TRGSEL(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT7_ADC0TRGSEL_SHIFT)) & SIM_SOPT7_ADC0TRGSEL_MASK)
 
#define SIM_SOPT7_ADC0PRETRGSEL_MASK   (0x10U)
 
#define SIM_SOPT7_ADC0PRETRGSEL_SHIFT   (4U)
 
#define SIM_SOPT7_ADC0PRETRGSEL(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT7_ADC0PRETRGSEL_SHIFT)) & SIM_SOPT7_ADC0PRETRGSEL_MASK)
 
#define SIM_SOPT7_ADC0ALTTRGEN_MASK   (0x80U)
 
#define SIM_SOPT7_ADC0ALTTRGEN_SHIFT   (7U)
 
#define SIM_SOPT7_ADC0ALTTRGEN(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT7_ADC0ALTTRGEN_SHIFT)) & SIM_SOPT7_ADC0ALTTRGEN_MASK)
 
#define SIM_SOPT7_ADC1TRGSEL_MASK   (0xF00U)
 
#define SIM_SOPT7_ADC1TRGSEL_SHIFT   (8U)
 
#define SIM_SOPT7_ADC1TRGSEL(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT7_ADC1TRGSEL_SHIFT)) & SIM_SOPT7_ADC1TRGSEL_MASK)
 
#define SIM_SOPT7_ADC1PRETRGSEL_MASK   (0x1000U)
 
#define SIM_SOPT7_ADC1PRETRGSEL_SHIFT   (12U)
 
#define SIM_SOPT7_ADC1PRETRGSEL(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT7_ADC1PRETRGSEL_SHIFT)) & SIM_SOPT7_ADC1PRETRGSEL_MASK)
 
#define SIM_SOPT7_ADC1ALTTRGEN_MASK   (0x8000U)
 
#define SIM_SOPT7_ADC1ALTTRGEN_SHIFT   (15U)
 
#define SIM_SOPT7_ADC1ALTTRGEN(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SOPT7_ADC1ALTTRGEN_SHIFT)) & SIM_SOPT7_ADC1ALTTRGEN_MASK)
 
SDID - System Device Identification Register
#define SIM_SDID_PINID_MASK   (0xFU)
 
#define SIM_SDID_PINID_SHIFT   (0U)
 
#define SIM_SDID_PINID(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SDID_PINID_SHIFT)) & SIM_SDID_PINID_MASK)
 
#define SIM_SDID_FAMID_MASK   (0x70U)
 
#define SIM_SDID_FAMID_SHIFT   (4U)
 
#define SIM_SDID_FAMID(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SDID_FAMID_SHIFT)) & SIM_SDID_FAMID_MASK)
 
#define SIM_SDID_DIEID_MASK   (0xF80U)
 
#define SIM_SDID_DIEID_SHIFT   (7U)
 
#define SIM_SDID_DIEID(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SDID_DIEID_SHIFT)) & SIM_SDID_DIEID_MASK)
 
#define SIM_SDID_REVID_MASK   (0xF000U)
 
#define SIM_SDID_REVID_SHIFT   (12U)
 
#define SIM_SDID_REVID(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SDID_REVID_SHIFT)) & SIM_SDID_REVID_MASK)
 
#define SIM_SDID_SERIESID_MASK   (0xF00000U)
 
#define SIM_SDID_SERIESID_SHIFT   (20U)
 
#define SIM_SDID_SERIESID(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SDID_SERIESID_SHIFT)) & SIM_SDID_SERIESID_MASK)
 
#define SIM_SDID_SUBFAMID_MASK   (0xF000000U)
 
#define SIM_SDID_SUBFAMID_SHIFT   (24U)
 
#define SIM_SDID_SUBFAMID(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SDID_SUBFAMID_SHIFT)) & SIM_SDID_SUBFAMID_MASK)
 
#define SIM_SDID_FAMILYID_MASK   (0xF0000000U)
 
#define SIM_SDID_FAMILYID_SHIFT   (28U)
 
#define SIM_SDID_FAMILYID(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SDID_FAMILYID_SHIFT)) & SIM_SDID_FAMILYID_MASK)
 
SCGC1 - System Clock Gating Control Register 1
#define SIM_SCGC1_I2C2_MASK   (0x40U)
 
#define SIM_SCGC1_I2C2_SHIFT   (6U)
 
#define SIM_SCGC1_I2C2(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC1_I2C2_SHIFT)) & SIM_SCGC1_I2C2_MASK)
 
#define SIM_SCGC1_UART4_MASK   (0x400U)
 
#define SIM_SCGC1_UART4_SHIFT   (10U)
 
#define SIM_SCGC1_UART4(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC1_UART4_SHIFT)) & SIM_SCGC1_UART4_MASK)
 
#define SIM_SCGC1_UART5_MASK   (0x800U)
 
#define SIM_SCGC1_UART5_SHIFT   (11U)
 
#define SIM_SCGC1_UART5(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC1_UART5_SHIFT)) & SIM_SCGC1_UART5_MASK)
 
SCGC2 - System Clock Gating Control Register 2
#define SIM_SCGC2_ENET_MASK   (0x1U)
 
#define SIM_SCGC2_ENET_SHIFT   (0U)
 
#define SIM_SCGC2_ENET(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC2_ENET_SHIFT)) & SIM_SCGC2_ENET_MASK)
 
#define SIM_SCGC2_DAC0_MASK   (0x1000U)
 
#define SIM_SCGC2_DAC0_SHIFT   (12U)
 
#define SIM_SCGC2_DAC0(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC2_DAC0_SHIFT)) & SIM_SCGC2_DAC0_MASK)
 
#define SIM_SCGC2_DAC1_MASK   (0x2000U)
 
#define SIM_SCGC2_DAC1_SHIFT   (13U)
 
#define SIM_SCGC2_DAC1(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC2_DAC1_SHIFT)) & SIM_SCGC2_DAC1_MASK)
 
SCGC3 - System Clock Gating Control Register 3
#define SIM_SCGC3_RNGA_MASK   (0x1U)
 
#define SIM_SCGC3_RNGA_SHIFT   (0U)
 
#define SIM_SCGC3_RNGA(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC3_RNGA_SHIFT)) & SIM_SCGC3_RNGA_MASK)
 
#define SIM_SCGC3_SPI2_MASK   (0x1000U)
 
#define SIM_SCGC3_SPI2_SHIFT   (12U)
 
#define SIM_SCGC3_SPI2(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC3_SPI2_SHIFT)) & SIM_SCGC3_SPI2_MASK)
 
#define SIM_SCGC3_SDHC_MASK   (0x20000U)
 
#define SIM_SCGC3_SDHC_SHIFT   (17U)
 
#define SIM_SCGC3_SDHC(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC3_SDHC_SHIFT)) & SIM_SCGC3_SDHC_MASK)
 
#define SIM_SCGC3_FTM2_MASK   (0x1000000U)
 
#define SIM_SCGC3_FTM2_SHIFT   (24U)
 
#define SIM_SCGC3_FTM2(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC3_FTM2_SHIFT)) & SIM_SCGC3_FTM2_MASK)
 
#define SIM_SCGC3_FTM3_MASK   (0x2000000U)
 
#define SIM_SCGC3_FTM3_SHIFT   (25U)
 
#define SIM_SCGC3_FTM3(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC3_FTM3_SHIFT)) & SIM_SCGC3_FTM3_MASK)
 
#define SIM_SCGC3_ADC1_MASK   (0x8000000U)
 
#define SIM_SCGC3_ADC1_SHIFT   (27U)
 
#define SIM_SCGC3_ADC1(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC3_ADC1_SHIFT)) & SIM_SCGC3_ADC1_MASK)
 
SCGC4 - System Clock Gating Control Register 4
#define SIM_SCGC4_EWM_MASK   (0x2U)
 
#define SIM_SCGC4_EWM_SHIFT   (1U)
 
#define SIM_SCGC4_EWM(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC4_EWM_SHIFT)) & SIM_SCGC4_EWM_MASK)
 
#define SIM_SCGC4_CMT_MASK   (0x4U)
 
#define SIM_SCGC4_CMT_SHIFT   (2U)
 
#define SIM_SCGC4_CMT(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC4_CMT_SHIFT)) & SIM_SCGC4_CMT_MASK)
 
#define SIM_SCGC4_I2C0_MASK   (0x40U)
 
#define SIM_SCGC4_I2C0_SHIFT   (6U)
 
#define SIM_SCGC4_I2C0(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC4_I2C0_SHIFT)) & SIM_SCGC4_I2C0_MASK)
 
#define SIM_SCGC4_I2C1_MASK   (0x80U)
 
#define SIM_SCGC4_I2C1_SHIFT   (7U)
 
#define SIM_SCGC4_I2C1(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC4_I2C1_SHIFT)) & SIM_SCGC4_I2C1_MASK)
 
#define SIM_SCGC4_UART0_MASK   (0x400U)
 
#define SIM_SCGC4_UART0_SHIFT   (10U)
 
#define SIM_SCGC4_UART0(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC4_UART0_SHIFT)) & SIM_SCGC4_UART0_MASK)
 
#define SIM_SCGC4_UART1_MASK   (0x800U)
 
#define SIM_SCGC4_UART1_SHIFT   (11U)
 
#define SIM_SCGC4_UART1(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC4_UART1_SHIFT)) & SIM_SCGC4_UART1_MASK)
 
#define SIM_SCGC4_UART2_MASK   (0x1000U)
 
#define SIM_SCGC4_UART2_SHIFT   (12U)
 
#define SIM_SCGC4_UART2(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC4_UART2_SHIFT)) & SIM_SCGC4_UART2_MASK)
 
#define SIM_SCGC4_UART3_MASK   (0x2000U)
 
#define SIM_SCGC4_UART3_SHIFT   (13U)
 
#define SIM_SCGC4_UART3(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC4_UART3_SHIFT)) & SIM_SCGC4_UART3_MASK)
 
#define SIM_SCGC4_USBOTG_MASK   (0x40000U)
 
#define SIM_SCGC4_USBOTG_SHIFT   (18U)
 
#define SIM_SCGC4_USBOTG(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC4_USBOTG_SHIFT)) & SIM_SCGC4_USBOTG_MASK)
 
#define SIM_SCGC4_CMP_MASK   (0x80000U)
 
#define SIM_SCGC4_CMP_SHIFT   (19U)
 
#define SIM_SCGC4_CMP(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC4_CMP_SHIFT)) & SIM_SCGC4_CMP_MASK)
 
#define SIM_SCGC4_VREF_MASK   (0x100000U)
 
#define SIM_SCGC4_VREF_SHIFT   (20U)
 
#define SIM_SCGC4_VREF(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC4_VREF_SHIFT)) & SIM_SCGC4_VREF_MASK)
 
SCGC5 - System Clock Gating Control Register 5
#define SIM_SCGC5_LPTMR_MASK   (0x1U)
 
#define SIM_SCGC5_LPTMR_SHIFT   (0U)
 
#define SIM_SCGC5_LPTMR(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC5_LPTMR_SHIFT)) & SIM_SCGC5_LPTMR_MASK)
 
#define SIM_SCGC5_PORTA_MASK   (0x200U)
 
#define SIM_SCGC5_PORTA_SHIFT   (9U)
 
#define SIM_SCGC5_PORTA(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC5_PORTA_SHIFT)) & SIM_SCGC5_PORTA_MASK)
 
#define SIM_SCGC5_PORTB_MASK   (0x400U)
 
#define SIM_SCGC5_PORTB_SHIFT   (10U)
 
#define SIM_SCGC5_PORTB(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC5_PORTB_SHIFT)) & SIM_SCGC5_PORTB_MASK)
 
#define SIM_SCGC5_PORTC_MASK   (0x800U)
 
#define SIM_SCGC5_PORTC_SHIFT   (11U)
 
#define SIM_SCGC5_PORTC(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC5_PORTC_SHIFT)) & SIM_SCGC5_PORTC_MASK)
 
#define SIM_SCGC5_PORTD_MASK   (0x1000U)
 
#define SIM_SCGC5_PORTD_SHIFT   (12U)
 
#define SIM_SCGC5_PORTD(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC5_PORTD_SHIFT)) & SIM_SCGC5_PORTD_MASK)
 
#define SIM_SCGC5_PORTE_MASK   (0x2000U)
 
#define SIM_SCGC5_PORTE_SHIFT   (13U)
 
#define SIM_SCGC5_PORTE(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC5_PORTE_SHIFT)) & SIM_SCGC5_PORTE_MASK)
 
SCGC6 - System Clock Gating Control Register 6
#define SIM_SCGC6_FTF_MASK   (0x1U)
 
#define SIM_SCGC6_FTF_SHIFT   (0U)
 
#define SIM_SCGC6_FTF(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC6_FTF_SHIFT)) & SIM_SCGC6_FTF_MASK)
 
#define SIM_SCGC6_DMAMUX_MASK   (0x2U)
 
#define SIM_SCGC6_DMAMUX_SHIFT   (1U)
 
#define SIM_SCGC6_DMAMUX(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC6_DMAMUX_SHIFT)) & SIM_SCGC6_DMAMUX_MASK)
 
#define SIM_SCGC6_FLEXCAN0_MASK   (0x10U)
 
#define SIM_SCGC6_FLEXCAN0_SHIFT   (4U)
 
#define SIM_SCGC6_FLEXCAN0(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC6_FLEXCAN0_SHIFT)) & SIM_SCGC6_FLEXCAN0_MASK)
 
#define SIM_SCGC6_RNGA_MASK   (0x200U)
 
#define SIM_SCGC6_RNGA_SHIFT   (9U)
 
#define SIM_SCGC6_RNGA(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC6_RNGA_SHIFT)) & SIM_SCGC6_RNGA_MASK)
 
#define SIM_SCGC6_SPI0_MASK   (0x1000U)
 
#define SIM_SCGC6_SPI0_SHIFT   (12U)
 
#define SIM_SCGC6_SPI0(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC6_SPI0_SHIFT)) & SIM_SCGC6_SPI0_MASK)
 
#define SIM_SCGC6_SPI1_MASK   (0x2000U)
 
#define SIM_SCGC6_SPI1_SHIFT   (13U)
 
#define SIM_SCGC6_SPI1(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC6_SPI1_SHIFT)) & SIM_SCGC6_SPI1_MASK)
 
#define SIM_SCGC6_I2S_MASK   (0x8000U)
 
#define SIM_SCGC6_I2S_SHIFT   (15U)
 
#define SIM_SCGC6_I2S(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC6_I2S_SHIFT)) & SIM_SCGC6_I2S_MASK)
 
#define SIM_SCGC6_CRC_MASK   (0x40000U)
 
#define SIM_SCGC6_CRC_SHIFT   (18U)
 
#define SIM_SCGC6_CRC(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC6_CRC_SHIFT)) & SIM_SCGC6_CRC_MASK)
 
#define SIM_SCGC6_USBDCD_MASK   (0x200000U)
 
#define SIM_SCGC6_USBDCD_SHIFT   (21U)
 
#define SIM_SCGC6_USBDCD(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC6_USBDCD_SHIFT)) & SIM_SCGC6_USBDCD_MASK)
 
#define SIM_SCGC6_PDB_MASK   (0x400000U)
 
#define SIM_SCGC6_PDB_SHIFT   (22U)
 
#define SIM_SCGC6_PDB(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC6_PDB_SHIFT)) & SIM_SCGC6_PDB_MASK)
 
#define SIM_SCGC6_PIT_MASK   (0x800000U)
 
#define SIM_SCGC6_PIT_SHIFT   (23U)
 
#define SIM_SCGC6_PIT(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC6_PIT_SHIFT)) & SIM_SCGC6_PIT_MASK)
 
#define SIM_SCGC6_FTM0_MASK   (0x1000000U)
 
#define SIM_SCGC6_FTM0_SHIFT   (24U)
 
#define SIM_SCGC6_FTM0(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC6_FTM0_SHIFT)) & SIM_SCGC6_FTM0_MASK)
 
#define SIM_SCGC6_FTM1_MASK   (0x2000000U)
 
#define SIM_SCGC6_FTM1_SHIFT   (25U)
 
#define SIM_SCGC6_FTM1(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC6_FTM1_SHIFT)) & SIM_SCGC6_FTM1_MASK)
 
#define SIM_SCGC6_FTM2_MASK   (0x4000000U)
 
#define SIM_SCGC6_FTM2_SHIFT   (26U)
 
#define SIM_SCGC6_FTM2(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC6_FTM2_SHIFT)) & SIM_SCGC6_FTM2_MASK)
 
#define SIM_SCGC6_ADC0_MASK   (0x8000000U)
 
#define SIM_SCGC6_ADC0_SHIFT   (27U)
 
#define SIM_SCGC6_ADC0(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC6_ADC0_SHIFT)) & SIM_SCGC6_ADC0_MASK)
 
#define SIM_SCGC6_RTC_MASK   (0x20000000U)
 
#define SIM_SCGC6_RTC_SHIFT   (29U)
 
#define SIM_SCGC6_RTC(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC6_RTC_SHIFT)) & SIM_SCGC6_RTC_MASK)
 
#define SIM_SCGC6_DAC0_MASK   (0x80000000U)
 
#define SIM_SCGC6_DAC0_SHIFT   (31U)
 
#define SIM_SCGC6_DAC0(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC6_DAC0_SHIFT)) & SIM_SCGC6_DAC0_MASK)
 
SCGC7 - System Clock Gating Control Register 7
#define SIM_SCGC7_FLEXBUS_MASK   (0x1U)
 
#define SIM_SCGC7_FLEXBUS_SHIFT   (0U)
 
#define SIM_SCGC7_FLEXBUS(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC7_FLEXBUS_SHIFT)) & SIM_SCGC7_FLEXBUS_MASK)
 
#define SIM_SCGC7_DMA_MASK   (0x2U)
 
#define SIM_SCGC7_DMA_SHIFT   (1U)
 
#define SIM_SCGC7_DMA(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC7_DMA_SHIFT)) & SIM_SCGC7_DMA_MASK)
 
#define SIM_SCGC7_MPU_MASK   (0x4U)
 
#define SIM_SCGC7_MPU_SHIFT   (2U)
 
#define SIM_SCGC7_MPU(x)   (((uint32_t)(((uint32_t)(x)) << SIM_SCGC7_MPU_SHIFT)) & SIM_SCGC7_MPU_MASK)
 
CLKDIV1 - System Clock Divider Register 1
#define SIM_CLKDIV1_OUTDIV4_MASK   (0xF0000U)
 
#define SIM_CLKDIV1_OUTDIV4_SHIFT   (16U)
 
#define SIM_CLKDIV1_OUTDIV4(x)   (((uint32_t)(((uint32_t)(x)) << SIM_CLKDIV1_OUTDIV4_SHIFT)) & SIM_CLKDIV1_OUTDIV4_MASK)
 
#define SIM_CLKDIV1_OUTDIV3_MASK   (0xF00000U)
 
#define SIM_CLKDIV1_OUTDIV3_SHIFT   (20U)
 
#define SIM_CLKDIV1_OUTDIV3(x)   (((uint32_t)(((uint32_t)(x)) << SIM_CLKDIV1_OUTDIV3_SHIFT)) & SIM_CLKDIV1_OUTDIV3_MASK)
 
#define SIM_CLKDIV1_OUTDIV2_MASK   (0xF000000U)
 
#define SIM_CLKDIV1_OUTDIV2_SHIFT   (24U)
 
#define SIM_CLKDIV1_OUTDIV2(x)   (((uint32_t)(((uint32_t)(x)) << SIM_CLKDIV1_OUTDIV2_SHIFT)) & SIM_CLKDIV1_OUTDIV2_MASK)
 
#define SIM_CLKDIV1_OUTDIV1_MASK   (0xF0000000U)
 
#define SIM_CLKDIV1_OUTDIV1_SHIFT   (28U)
 
#define SIM_CLKDIV1_OUTDIV1(x)   (((uint32_t)(((uint32_t)(x)) << SIM_CLKDIV1_OUTDIV1_SHIFT)) & SIM_CLKDIV1_OUTDIV1_MASK)
 
CLKDIV2 - System Clock Divider Register 2
#define SIM_CLKDIV2_USBFRAC_MASK   (0x1U)
 
#define SIM_CLKDIV2_USBFRAC_SHIFT   (0U)
 
#define SIM_CLKDIV2_USBFRAC(x)   (((uint32_t)(((uint32_t)(x)) << SIM_CLKDIV2_USBFRAC_SHIFT)) & SIM_CLKDIV2_USBFRAC_MASK)
 
#define SIM_CLKDIV2_USBDIV_MASK   (0xEU)
 
#define SIM_CLKDIV2_USBDIV_SHIFT   (1U)
 
#define SIM_CLKDIV2_USBDIV(x)   (((uint32_t)(((uint32_t)(x)) << SIM_CLKDIV2_USBDIV_SHIFT)) & SIM_CLKDIV2_USBDIV_MASK)
 
FCFG1 - Flash Configuration Register 1
#define SIM_FCFG1_FLASHDIS_MASK   (0x1U)
 
#define SIM_FCFG1_FLASHDIS_SHIFT   (0U)
 
#define SIM_FCFG1_FLASHDIS(x)   (((uint32_t)(((uint32_t)(x)) << SIM_FCFG1_FLASHDIS_SHIFT)) & SIM_FCFG1_FLASHDIS_MASK)
 
#define SIM_FCFG1_FLASHDOZE_MASK   (0x2U)
 
#define SIM_FCFG1_FLASHDOZE_SHIFT   (1U)
 
#define SIM_FCFG1_FLASHDOZE(x)   (((uint32_t)(((uint32_t)(x)) << SIM_FCFG1_FLASHDOZE_SHIFT)) & SIM_FCFG1_FLASHDOZE_MASK)
 
#define SIM_FCFG1_DEPART_MASK   (0xF00U)
 
#define SIM_FCFG1_DEPART_SHIFT   (8U)
 
#define SIM_FCFG1_DEPART(x)   (((uint32_t)(((uint32_t)(x)) << SIM_FCFG1_DEPART_SHIFT)) & SIM_FCFG1_DEPART_MASK)
 
#define SIM_FCFG1_EESIZE_MASK   (0xF0000U)
 
#define SIM_FCFG1_EESIZE_SHIFT   (16U)
 
#define SIM_FCFG1_EESIZE(x)   (((uint32_t)(((uint32_t)(x)) << SIM_FCFG1_EESIZE_SHIFT)) & SIM_FCFG1_EESIZE_MASK)
 
#define SIM_FCFG1_PFSIZE_MASK   (0xF000000U)
 
#define SIM_FCFG1_PFSIZE_SHIFT   (24U)
 
#define SIM_FCFG1_PFSIZE(x)   (((uint32_t)(((uint32_t)(x)) << SIM_FCFG1_PFSIZE_SHIFT)) & SIM_FCFG1_PFSIZE_MASK)
 
#define SIM_FCFG1_NVMSIZE_MASK   (0xF0000000U)
 
#define SIM_FCFG1_NVMSIZE_SHIFT   (28U)
 
#define SIM_FCFG1_NVMSIZE(x)   (((uint32_t)(((uint32_t)(x)) << SIM_FCFG1_NVMSIZE_SHIFT)) & SIM_FCFG1_NVMSIZE_MASK)
 
FCFG2 - Flash Configuration Register 2
#define SIM_FCFG2_MAXADDR1_MASK   (0x7F0000U)
 
#define SIM_FCFG2_MAXADDR1_SHIFT   (16U)
 
#define SIM_FCFG2_MAXADDR1(x)   (((uint32_t)(((uint32_t)(x)) << SIM_FCFG2_MAXADDR1_SHIFT)) & SIM_FCFG2_MAXADDR1_MASK)
 
#define SIM_FCFG2_PFLSH_MASK   (0x800000U)
 
#define SIM_FCFG2_PFLSH_SHIFT   (23U)
 
#define SIM_FCFG2_PFLSH(x)   (((uint32_t)(((uint32_t)(x)) << SIM_FCFG2_PFLSH_SHIFT)) & SIM_FCFG2_PFLSH_MASK)
 
#define SIM_FCFG2_MAXADDR0_MASK   (0x7F000000U)
 
#define SIM_FCFG2_MAXADDR0_SHIFT   (24U)
 
#define SIM_FCFG2_MAXADDR0(x)   (((uint32_t)(((uint32_t)(x)) << SIM_FCFG2_MAXADDR0_SHIFT)) & SIM_FCFG2_MAXADDR0_MASK)
 
UIDH - Unique Identification Register High
#define SIM_UIDH_UID_MASK   (0xFFFFFFFFU)
 
#define SIM_UIDH_UID_SHIFT   (0U)
 
#define SIM_UIDH_UID(x)   (((uint32_t)(((uint32_t)(x)) << SIM_UIDH_UID_SHIFT)) & SIM_UIDH_UID_MASK)
 
UIDMH - Unique Identification Register Mid-High
#define SIM_UIDMH_UID_MASK   (0xFFFFFFFFU)
 
#define SIM_UIDMH_UID_SHIFT   (0U)
 
#define SIM_UIDMH_UID(x)   (((uint32_t)(((uint32_t)(x)) << SIM_UIDMH_UID_SHIFT)) & SIM_UIDMH_UID_MASK)
 
UIDML - Unique Identification Register Mid Low
#define SIM_UIDML_UID_MASK   (0xFFFFFFFFU)
 
#define SIM_UIDML_UID_SHIFT   (0U)
 
#define SIM_UIDML_UID(x)   (((uint32_t)(((uint32_t)(x)) << SIM_UIDML_UID_SHIFT)) & SIM_UIDML_UID_MASK)
 
UIDL - Unique Identification Register Low
#define SIM_UIDL_UID_MASK   (0xFFFFFFFFU)
 
#define SIM_UIDL_UID_SHIFT   (0U)
 
#define SIM_UIDL_UID(x)   (((uint32_t)(((uint32_t)(x)) << SIM_UIDL_UID_SHIFT)) & SIM_UIDL_UID_MASK)
 
PMPROT - Power Mode Protection register
#define SMC_PMPROT_AVLLS_MASK   (0x2U)
 
#define SMC_PMPROT_AVLLS_SHIFT   (1U)
 
#define SMC_PMPROT_AVLLS(x)   (((uint8_t)(((uint8_t)(x)) << SMC_PMPROT_AVLLS_SHIFT)) & SMC_PMPROT_AVLLS_MASK)
 
#define SMC_PMPROT_ALLS_MASK   (0x8U)
 
#define SMC_PMPROT_ALLS_SHIFT   (3U)
 
#define SMC_PMPROT_ALLS(x)   (((uint8_t)(((uint8_t)(x)) << SMC_PMPROT_ALLS_SHIFT)) & SMC_PMPROT_ALLS_MASK)
 
#define SMC_PMPROT_AVLP_MASK   (0x20U)
 
#define SMC_PMPROT_AVLP_SHIFT   (5U)
 
#define SMC_PMPROT_AVLP(x)   (((uint8_t)(((uint8_t)(x)) << SMC_PMPROT_AVLP_SHIFT)) & SMC_PMPROT_AVLP_MASK)
 
PMCTRL - Power Mode Control register
#define SMC_PMCTRL_STOPM_MASK   (0x7U)
 
#define SMC_PMCTRL_STOPM_SHIFT   (0U)
 
#define SMC_PMCTRL_STOPM(x)   (((uint8_t)(((uint8_t)(x)) << SMC_PMCTRL_STOPM_SHIFT)) & SMC_PMCTRL_STOPM_MASK)
 
#define SMC_PMCTRL_STOPA_MASK   (0x8U)
 
#define SMC_PMCTRL_STOPA_SHIFT   (3U)
 
#define SMC_PMCTRL_STOPA(x)   (((uint8_t)(((uint8_t)(x)) << SMC_PMCTRL_STOPA_SHIFT)) & SMC_PMCTRL_STOPA_MASK)
 
#define SMC_PMCTRL_RUNM_MASK   (0x60U)
 
#define SMC_PMCTRL_RUNM_SHIFT   (5U)
 
#define SMC_PMCTRL_RUNM(x)   (((uint8_t)(((uint8_t)(x)) << SMC_PMCTRL_RUNM_SHIFT)) & SMC_PMCTRL_RUNM_MASK)
 
#define SMC_PMCTRL_LPWUI_MASK   (0x80U)
 
#define SMC_PMCTRL_LPWUI_SHIFT   (7U)
 
#define SMC_PMCTRL_LPWUI(x)   (((uint8_t)(((uint8_t)(x)) << SMC_PMCTRL_LPWUI_SHIFT)) & SMC_PMCTRL_LPWUI_MASK)
 
VLLSCTRL - VLLS Control register
#define SMC_VLLSCTRL_VLLSM_MASK   (0x7U)
 
#define SMC_VLLSCTRL_VLLSM_SHIFT   (0U)
 
#define SMC_VLLSCTRL_VLLSM(x)   (((uint8_t)(((uint8_t)(x)) << SMC_VLLSCTRL_VLLSM_SHIFT)) & SMC_VLLSCTRL_VLLSM_MASK)
 
#define SMC_VLLSCTRL_PORPO_MASK   (0x20U)
 
#define SMC_VLLSCTRL_PORPO_SHIFT   (5U)
 
#define SMC_VLLSCTRL_PORPO(x)   (((uint8_t)(((uint8_t)(x)) << SMC_VLLSCTRL_PORPO_SHIFT)) & SMC_VLLSCTRL_PORPO_MASK)
 
PMSTAT - Power Mode Status register
#define SMC_PMSTAT_PMSTAT_MASK   (0x7FU)
 
#define SMC_PMSTAT_PMSTAT_SHIFT   (0U)
 
#define SMC_PMSTAT_PMSTAT(x)   (((uint8_t)(((uint8_t)(x)) << SMC_PMSTAT_PMSTAT_SHIFT)) & SMC_PMSTAT_PMSTAT_MASK)
 
TCR - Transfer Count Register
#define SPI_TCR_SPI_TCNT_MASK   (0xFFFF0000U)
 
#define SPI_TCR_SPI_TCNT_SHIFT   (16U)
 
#define SPI_TCR_SPI_TCNT(x)   (((uint32_t)(((uint32_t)(x)) << SPI_TCR_SPI_TCNT_SHIFT)) & SPI_TCR_SPI_TCNT_MASK)
 
CTAR - Clock and Transfer Attributes Register (In Master Mode)
#define SPI_CTAR_BR_MASK   (0xFU)
 
#define SPI_CTAR_BR_SHIFT   (0U)
 
#define SPI_CTAR_BR(x)   (((uint32_t)(((uint32_t)(x)) << SPI_CTAR_BR_SHIFT)) & SPI_CTAR_BR_MASK)
 
#define SPI_CTAR_DT_MASK   (0xF0U)
 
#define SPI_CTAR_DT_SHIFT   (4U)
 
#define SPI_CTAR_DT(x)   (((uint32_t)(((uint32_t)(x)) << SPI_CTAR_DT_SHIFT)) & SPI_CTAR_DT_MASK)
 
#define SPI_CTAR_ASC_MASK   (0xF00U)
 
#define SPI_CTAR_ASC_SHIFT   (8U)
 
#define SPI_CTAR_ASC(x)   (((uint32_t)(((uint32_t)(x)) << SPI_CTAR_ASC_SHIFT)) & SPI_CTAR_ASC_MASK)
 
#define SPI_CTAR_CSSCK_MASK   (0xF000U)
 
#define SPI_CTAR_CSSCK_SHIFT   (12U)
 
#define SPI_CTAR_CSSCK(x)   (((uint32_t)(((uint32_t)(x)) << SPI_CTAR_CSSCK_SHIFT)) & SPI_CTAR_CSSCK_MASK)
 
#define SPI_CTAR_PBR_MASK   (0x30000U)
 
#define SPI_CTAR_PBR_SHIFT   (16U)
 
#define SPI_CTAR_PBR(x)   (((uint32_t)(((uint32_t)(x)) << SPI_CTAR_PBR_SHIFT)) & SPI_CTAR_PBR_MASK)
 
#define SPI_CTAR_PDT_MASK   (0xC0000U)
 
#define SPI_CTAR_PDT_SHIFT   (18U)
 
#define SPI_CTAR_PDT(x)   (((uint32_t)(((uint32_t)(x)) << SPI_CTAR_PDT_SHIFT)) & SPI_CTAR_PDT_MASK)
 
#define SPI_CTAR_PASC_MASK   (0x300000U)
 
#define SPI_CTAR_PASC_SHIFT   (20U)
 
#define SPI_CTAR_PASC(x)   (((uint32_t)(((uint32_t)(x)) << SPI_CTAR_PASC_SHIFT)) & SPI_CTAR_PASC_MASK)
 
#define SPI_CTAR_PCSSCK_MASK   (0xC00000U)
 
#define SPI_CTAR_PCSSCK_SHIFT   (22U)
 
#define SPI_CTAR_PCSSCK(x)   (((uint32_t)(((uint32_t)(x)) << SPI_CTAR_PCSSCK_SHIFT)) & SPI_CTAR_PCSSCK_MASK)
 
#define SPI_CTAR_LSBFE_MASK   (0x1000000U)
 
#define SPI_CTAR_LSBFE_SHIFT   (24U)
 
#define SPI_CTAR_LSBFE(x)   (((uint32_t)(((uint32_t)(x)) << SPI_CTAR_LSBFE_SHIFT)) & SPI_CTAR_LSBFE_MASK)
 
#define SPI_CTAR_CPHA_MASK   (0x2000000U)
 
#define SPI_CTAR_CPHA_SHIFT   (25U)
 
#define SPI_CTAR_CPHA(x)   (((uint32_t)(((uint32_t)(x)) << SPI_CTAR_CPHA_SHIFT)) & SPI_CTAR_CPHA_MASK)
 
#define SPI_CTAR_CPOL_MASK   (0x4000000U)
 
#define SPI_CTAR_CPOL_SHIFT   (26U)
 
#define SPI_CTAR_CPOL(x)   (((uint32_t)(((uint32_t)(x)) << SPI_CTAR_CPOL_SHIFT)) & SPI_CTAR_CPOL_MASK)
 
#define SPI_CTAR_FMSZ_MASK   (0x78000000U)
 
#define SPI_CTAR_FMSZ_SHIFT   (27U)
 
#define SPI_CTAR_FMSZ(x)   (((uint32_t)(((uint32_t)(x)) << SPI_CTAR_FMSZ_SHIFT)) & SPI_CTAR_FMSZ_MASK)
 
#define SPI_CTAR_DBR_MASK   (0x80000000U)
 
#define SPI_CTAR_DBR_SHIFT   (31U)
 
#define SPI_CTAR_DBR(x)   (((uint32_t)(((uint32_t)(x)) << SPI_CTAR_DBR_SHIFT)) & SPI_CTAR_DBR_MASK)
 
#define SPI_CTAR_COUNT   (2U)
 
CTAR_SLAVE - Clock and Transfer Attributes Register (In Slave Mode)
#define SPI_CTAR_SLAVE_CPHA_MASK   (0x2000000U)
 
#define SPI_CTAR_SLAVE_CPHA_SHIFT   (25U)
 
#define SPI_CTAR_SLAVE_CPHA(x)   (((uint32_t)(((uint32_t)(x)) << SPI_CTAR_SLAVE_CPHA_SHIFT)) & SPI_CTAR_SLAVE_CPHA_MASK)
 
#define SPI_CTAR_SLAVE_CPOL_MASK   (0x4000000U)
 
#define SPI_CTAR_SLAVE_CPOL_SHIFT   (26U)
 
#define SPI_CTAR_SLAVE_CPOL(x)   (((uint32_t)(((uint32_t)(x)) << SPI_CTAR_SLAVE_CPOL_SHIFT)) & SPI_CTAR_SLAVE_CPOL_MASK)
 
#define SPI_CTAR_SLAVE_FMSZ_MASK   (0xF8000000U)
 
#define SPI_CTAR_SLAVE_FMSZ_SHIFT   (27U)
 
#define SPI_CTAR_SLAVE_FMSZ(x)   (((uint32_t)(((uint32_t)(x)) << SPI_CTAR_SLAVE_FMSZ_SHIFT)) & SPI_CTAR_SLAVE_FMSZ_MASK)
 
#define SPI_CTAR_SLAVE_COUNT   (1U)
 
SR - Status Register
#define SPI_SR_POPNXTPTR_MASK   (0xFU)
 
#define SPI_SR_POPNXTPTR_SHIFT   (0U)
 
#define SPI_SR_POPNXTPTR(x)   (((uint32_t)(((uint32_t)(x)) << SPI_SR_POPNXTPTR_SHIFT)) & SPI_SR_POPNXTPTR_MASK)
 
#define SPI_SR_RXCTR_MASK   (0xF0U)
 
#define SPI_SR_RXCTR_SHIFT   (4U)
 
#define SPI_SR_RXCTR(x)   (((uint32_t)(((uint32_t)(x)) << SPI_SR_RXCTR_SHIFT)) & SPI_SR_RXCTR_MASK)
 
#define SPI_SR_TXNXTPTR_MASK   (0xF00U)
 
#define SPI_SR_TXNXTPTR_SHIFT   (8U)
 
#define SPI_SR_TXNXTPTR(x)   (((uint32_t)(((uint32_t)(x)) << SPI_SR_TXNXTPTR_SHIFT)) & SPI_SR_TXNXTPTR_MASK)
 
#define SPI_SR_TXCTR_MASK   (0xF000U)
 
#define SPI_SR_TXCTR_SHIFT   (12U)
 
#define SPI_SR_TXCTR(x)   (((uint32_t)(((uint32_t)(x)) << SPI_SR_TXCTR_SHIFT)) & SPI_SR_TXCTR_MASK)
 
#define SPI_SR_RFDF_MASK   (0x20000U)
 
#define SPI_SR_RFDF_SHIFT   (17U)
 
#define SPI_SR_RFDF(x)   (((uint32_t)(((uint32_t)(x)) << SPI_SR_RFDF_SHIFT)) & SPI_SR_RFDF_MASK)
 
#define SPI_SR_RFOF_MASK   (0x80000U)
 
#define SPI_SR_RFOF_SHIFT   (19U)
 
#define SPI_SR_RFOF(x)   (((uint32_t)(((uint32_t)(x)) << SPI_SR_RFOF_SHIFT)) & SPI_SR_RFOF_MASK)
 
#define SPI_SR_TFFF_MASK   (0x2000000U)
 
#define SPI_SR_TFFF_SHIFT   (25U)
 
#define SPI_SR_TFFF(x)   (((uint32_t)(((uint32_t)(x)) << SPI_SR_TFFF_SHIFT)) & SPI_SR_TFFF_MASK)
 
#define SPI_SR_TFUF_MASK   (0x8000000U)
 
#define SPI_SR_TFUF_SHIFT   (27U)
 
#define SPI_SR_TFUF(x)   (((uint32_t)(((uint32_t)(x)) << SPI_SR_TFUF_SHIFT)) & SPI_SR_TFUF_MASK)
 
#define SPI_SR_EOQF_MASK   (0x10000000U)
 
#define SPI_SR_EOQF_SHIFT   (28U)
 
#define SPI_SR_EOQF(x)   (((uint32_t)(((uint32_t)(x)) << SPI_SR_EOQF_SHIFT)) & SPI_SR_EOQF_MASK)
 
#define SPI_SR_TXRXS_MASK   (0x40000000U)
 
#define SPI_SR_TXRXS_SHIFT   (30U)
 
#define SPI_SR_TXRXS(x)   (((uint32_t)(((uint32_t)(x)) << SPI_SR_TXRXS_SHIFT)) & SPI_SR_TXRXS_MASK)
 
#define SPI_SR_TCF_MASK   (0x80000000U)
 
#define SPI_SR_TCF_SHIFT   (31U)
 
#define SPI_SR_TCF(x)   (((uint32_t)(((uint32_t)(x)) << SPI_SR_TCF_SHIFT)) & SPI_SR_TCF_MASK)
 
RSER - DMA/Interrupt Request Select and Enable Register
#define SPI_RSER_RFDF_DIRS_MASK   (0x10000U)
 
#define SPI_RSER_RFDF_DIRS_SHIFT   (16U)
 
#define SPI_RSER_RFDF_DIRS(x)   (((uint32_t)(((uint32_t)(x)) << SPI_RSER_RFDF_DIRS_SHIFT)) & SPI_RSER_RFDF_DIRS_MASK)
 
#define SPI_RSER_RFDF_RE_MASK   (0x20000U)
 
#define SPI_RSER_RFDF_RE_SHIFT   (17U)
 
#define SPI_RSER_RFDF_RE(x)   (((uint32_t)(((uint32_t)(x)) << SPI_RSER_RFDF_RE_SHIFT)) & SPI_RSER_RFDF_RE_MASK)
 
#define SPI_RSER_RFOF_RE_MASK   (0x80000U)
 
#define SPI_RSER_RFOF_RE_SHIFT   (19U)
 
#define SPI_RSER_RFOF_RE(x)   (((uint32_t)(((uint32_t)(x)) << SPI_RSER_RFOF_RE_SHIFT)) & SPI_RSER_RFOF_RE_MASK)
 
#define SPI_RSER_TFFF_DIRS_MASK   (0x1000000U)
 
#define SPI_RSER_TFFF_DIRS_SHIFT   (24U)
 
#define SPI_RSER_TFFF_DIRS(x)   (((uint32_t)(((uint32_t)(x)) << SPI_RSER_TFFF_DIRS_SHIFT)) & SPI_RSER_TFFF_DIRS_MASK)
 
#define SPI_RSER_TFFF_RE_MASK   (0x2000000U)
 
#define SPI_RSER_TFFF_RE_SHIFT   (25U)
 
#define SPI_RSER_TFFF_RE(x)   (((uint32_t)(((uint32_t)(x)) << SPI_RSER_TFFF_RE_SHIFT)) & SPI_RSER_TFFF_RE_MASK)
 
#define SPI_RSER_TFUF_RE_MASK   (0x8000000U)
 
#define SPI_RSER_TFUF_RE_SHIFT   (27U)
 
#define SPI_RSER_TFUF_RE(x)   (((uint32_t)(((uint32_t)(x)) << SPI_RSER_TFUF_RE_SHIFT)) & SPI_RSER_TFUF_RE_MASK)
 
#define SPI_RSER_EOQF_RE_MASK   (0x10000000U)
 
#define SPI_RSER_EOQF_RE_SHIFT   (28U)
 
#define SPI_RSER_EOQF_RE(x)   (((uint32_t)(((uint32_t)(x)) << SPI_RSER_EOQF_RE_SHIFT)) & SPI_RSER_EOQF_RE_MASK)
 
#define SPI_RSER_TCF_RE_MASK   (0x80000000U)
 
#define SPI_RSER_TCF_RE_SHIFT   (31U)
 
#define SPI_RSER_TCF_RE(x)   (((uint32_t)(((uint32_t)(x)) << SPI_RSER_TCF_RE_SHIFT)) & SPI_RSER_TCF_RE_MASK)
 
PUSHR - PUSH TX FIFO Register In Master Mode
#define SPI_PUSHR_TXDATA_MASK   (0xFFFFU)
 
#define SPI_PUSHR_TXDATA_SHIFT   (0U)
 
#define SPI_PUSHR_TXDATA(x)   (((uint32_t)(((uint32_t)(x)) << SPI_PUSHR_TXDATA_SHIFT)) & SPI_PUSHR_TXDATA_MASK)
 
#define SPI_PUSHR_PCS_MASK   (0x3F0000U)
 
#define SPI_PUSHR_PCS_SHIFT   (16U)
 
#define SPI_PUSHR_PCS(x)   (((uint32_t)(((uint32_t)(x)) << SPI_PUSHR_PCS_SHIFT)) & SPI_PUSHR_PCS_MASK)
 
#define SPI_PUSHR_CTCNT_MASK   (0x4000000U)
 
#define SPI_PUSHR_CTCNT_SHIFT   (26U)
 
#define SPI_PUSHR_CTCNT(x)   (((uint32_t)(((uint32_t)(x)) << SPI_PUSHR_CTCNT_SHIFT)) & SPI_PUSHR_CTCNT_MASK)
 
#define SPI_PUSHR_EOQ_MASK   (0x8000000U)
 
#define SPI_PUSHR_EOQ_SHIFT   (27U)
 
#define SPI_PUSHR_EOQ(x)   (((uint32_t)(((uint32_t)(x)) << SPI_PUSHR_EOQ_SHIFT)) & SPI_PUSHR_EOQ_MASK)
 
#define SPI_PUSHR_CTAS_MASK   (0x70000000U)
 
#define SPI_PUSHR_CTAS_SHIFT   (28U)
 
#define SPI_PUSHR_CTAS(x)   (((uint32_t)(((uint32_t)(x)) << SPI_PUSHR_CTAS_SHIFT)) & SPI_PUSHR_CTAS_MASK)
 
#define SPI_PUSHR_CONT_MASK   (0x80000000U)
 
#define SPI_PUSHR_CONT_SHIFT   (31U)
 
#define SPI_PUSHR_CONT(x)   (((uint32_t)(((uint32_t)(x)) << SPI_PUSHR_CONT_SHIFT)) & SPI_PUSHR_CONT_MASK)
 
PUSHR_SLAVE - PUSH TX FIFO Register In Slave Mode
#define SPI_PUSHR_SLAVE_TXDATA_MASK   (0xFFFFFFFFU)
 
#define SPI_PUSHR_SLAVE_TXDATA_SHIFT   (0U)
 
#define SPI_PUSHR_SLAVE_TXDATA(x)   (((uint32_t)(((uint32_t)(x)) << SPI_PUSHR_SLAVE_TXDATA_SHIFT)) & SPI_PUSHR_SLAVE_TXDATA_MASK)
 
POPR - POP RX FIFO Register
#define SPI_POPR_RXDATA_MASK   (0xFFFFFFFFU)
 
#define SPI_POPR_RXDATA_SHIFT   (0U)
 
#define SPI_POPR_RXDATA(x)   (((uint32_t)(((uint32_t)(x)) << SPI_POPR_RXDATA_SHIFT)) & SPI_POPR_RXDATA_MASK)
 
TXFR0 - Transmit FIFO Registers
#define SPI_TXFR0_TXDATA_MASK   (0xFFFFU)
 
#define SPI_TXFR0_TXDATA_SHIFT   (0U)
 
#define SPI_TXFR0_TXDATA(x)   (((uint32_t)(((uint32_t)(x)) << SPI_TXFR0_TXDATA_SHIFT)) & SPI_TXFR0_TXDATA_MASK)
 
#define SPI_TXFR0_TXCMD_TXDATA_MASK   (0xFFFF0000U)
 
#define SPI_TXFR0_TXCMD_TXDATA_SHIFT   (16U)
 
#define SPI_TXFR0_TXCMD_TXDATA(x)   (((uint32_t)(((uint32_t)(x)) << SPI_TXFR0_TXCMD_TXDATA_SHIFT)) & SPI_TXFR0_TXCMD_TXDATA_MASK)
 
TXFR1 - Transmit FIFO Registers
#define SPI_TXFR1_TXDATA_MASK   (0xFFFFU)
 
#define SPI_TXFR1_TXDATA_SHIFT   (0U)
 
#define SPI_TXFR1_TXDATA(x)   (((uint32_t)(((uint32_t)(x)) << SPI_TXFR1_TXDATA_SHIFT)) & SPI_TXFR1_TXDATA_MASK)
 
#define SPI_TXFR1_TXCMD_TXDATA_MASK   (0xFFFF0000U)
 
#define SPI_TXFR1_TXCMD_TXDATA_SHIFT   (16U)
 
#define SPI_TXFR1_TXCMD_TXDATA(x)   (((uint32_t)(((uint32_t)(x)) << SPI_TXFR1_TXCMD_TXDATA_SHIFT)) & SPI_TXFR1_TXCMD_TXDATA_MASK)
 
TXFR2 - Transmit FIFO Registers
#define SPI_TXFR2_TXDATA_MASK   (0xFFFFU)
 
#define SPI_TXFR2_TXDATA_SHIFT   (0U)
 
#define SPI_TXFR2_TXDATA(x)   (((uint32_t)(((uint32_t)(x)) << SPI_TXFR2_TXDATA_SHIFT)) & SPI_TXFR2_TXDATA_MASK)
 
#define SPI_TXFR2_TXCMD_TXDATA_MASK   (0xFFFF0000U)
 
#define SPI_TXFR2_TXCMD_TXDATA_SHIFT   (16U)
 
#define SPI_TXFR2_TXCMD_TXDATA(x)   (((uint32_t)(((uint32_t)(x)) << SPI_TXFR2_TXCMD_TXDATA_SHIFT)) & SPI_TXFR2_TXCMD_TXDATA_MASK)
 
TXFR3 - Transmit FIFO Registers
#define SPI_TXFR3_TXDATA_MASK   (0xFFFFU)
 
#define SPI_TXFR3_TXDATA_SHIFT   (0U)
 
#define SPI_TXFR3_TXDATA(x)   (((uint32_t)(((uint32_t)(x)) << SPI_TXFR3_TXDATA_SHIFT)) & SPI_TXFR3_TXDATA_MASK)
 
#define SPI_TXFR3_TXCMD_TXDATA_MASK   (0xFFFF0000U)
 
#define SPI_TXFR3_TXCMD_TXDATA_SHIFT   (16U)
 
#define SPI_TXFR3_TXCMD_TXDATA(x)   (((uint32_t)(((uint32_t)(x)) << SPI_TXFR3_TXCMD_TXDATA_SHIFT)) & SPI_TXFR3_TXCMD_TXDATA_MASK)
 
RXFR0 - Receive FIFO Registers
#define SPI_RXFR0_RXDATA_MASK   (0xFFFFFFFFU)
 
#define SPI_RXFR0_RXDATA_SHIFT   (0U)
 
#define SPI_RXFR0_RXDATA(x)   (((uint32_t)(((uint32_t)(x)) << SPI_RXFR0_RXDATA_SHIFT)) & SPI_RXFR0_RXDATA_MASK)
 
RXFR1 - Receive FIFO Registers
#define SPI_RXFR1_RXDATA_MASK   (0xFFFFFFFFU)
 
#define SPI_RXFR1_RXDATA_SHIFT   (0U)
 
#define SPI_RXFR1_RXDATA(x)   (((uint32_t)(((uint32_t)(x)) << SPI_RXFR1_RXDATA_SHIFT)) & SPI_RXFR1_RXDATA_MASK)
 
RXFR2 - Receive FIFO Registers
#define SPI_RXFR2_RXDATA_MASK   (0xFFFFFFFFU)
 
#define SPI_RXFR2_RXDATA_SHIFT   (0U)
 
#define SPI_RXFR2_RXDATA(x)   (((uint32_t)(((uint32_t)(x)) << SPI_RXFR2_RXDATA_SHIFT)) & SPI_RXFR2_RXDATA_MASK)
 
RXFR3 - Receive FIFO Registers
#define SPI_RXFR3_RXDATA_MASK   (0xFFFFFFFFU)
 
#define SPI_RXFR3_RXDATA_SHIFT   (0U)
 
#define SPI_RXFR3_RXDATA(x)   (((uint32_t)(((uint32_t)(x)) << SPI_RXFR3_RXDATA_SHIFT)) & SPI_RXFR3_RXDATA_MASK)
 
CESR - Control/Error Status Register
#define SYSMPU_CESR_VLD_MASK   (0x1U)
 
#define SYSMPU_CESR_VLD_SHIFT   (0U)
 
#define SYSMPU_CESR_VLD(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_CESR_VLD_SHIFT)) & SYSMPU_CESR_VLD_MASK)
 
#define SYSMPU_CESR_NRGD_MASK   (0xF00U)
 
#define SYSMPU_CESR_NRGD_SHIFT   (8U)
 
#define SYSMPU_CESR_NRGD(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_CESR_NRGD_SHIFT)) & SYSMPU_CESR_NRGD_MASK)
 
#define SYSMPU_CESR_NSP_MASK   (0xF000U)
 
#define SYSMPU_CESR_NSP_SHIFT   (12U)
 
#define SYSMPU_CESR_NSP(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_CESR_NSP_SHIFT)) & SYSMPU_CESR_NSP_MASK)
 
#define SYSMPU_CESR_HRL_MASK   (0xF0000U)
 
#define SYSMPU_CESR_HRL_SHIFT   (16U)
 
#define SYSMPU_CESR_HRL(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_CESR_HRL_SHIFT)) & SYSMPU_CESR_HRL_MASK)
 
#define SYSMPU_CESR_SPERR_MASK   (0xF8000000U)
 
#define SYSMPU_CESR_SPERR_SHIFT   (27U)
 
#define SYSMPU_CESR_SPERR(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_CESR_SPERR_SHIFT)) & SYSMPU_CESR_SPERR_MASK)
 
EAR - Error Address Register, slave port n
#define SYSMPU_EAR_EADDR_MASK   (0xFFFFFFFFU)
 
#define SYSMPU_EAR_EADDR_SHIFT   (0U)
 
#define SYSMPU_EAR_EADDR(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_EAR_EADDR_SHIFT)) & SYSMPU_EAR_EADDR_MASK)
 
#define SYSMPU_EAR_COUNT   (5U)
 
EDR - Error Detail Register, slave port n
#define SYSMPU_EDR_ERW_MASK   (0x1U)
 
#define SYSMPU_EDR_ERW_SHIFT   (0U)
 
#define SYSMPU_EDR_ERW(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_EDR_ERW_SHIFT)) & SYSMPU_EDR_ERW_MASK)
 
#define SYSMPU_EDR_EATTR_MASK   (0xEU)
 
#define SYSMPU_EDR_EATTR_SHIFT   (1U)
 
#define SYSMPU_EDR_EATTR(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_EDR_EATTR_SHIFT)) & SYSMPU_EDR_EATTR_MASK)
 
#define SYSMPU_EDR_EMN_MASK   (0xF0U)
 
#define SYSMPU_EDR_EMN_SHIFT   (4U)
 
#define SYSMPU_EDR_EMN(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_EDR_EMN_SHIFT)) & SYSMPU_EDR_EMN_MASK)
 
#define SYSMPU_EDR_EPID_MASK   (0xFF00U)
 
#define SYSMPU_EDR_EPID_SHIFT   (8U)
 
#define SYSMPU_EDR_EPID(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_EDR_EPID_SHIFT)) & SYSMPU_EDR_EPID_MASK)
 
#define SYSMPU_EDR_EACD_MASK   (0xFFFF0000U)
 
#define SYSMPU_EDR_EACD_SHIFT   (16U)
 
#define SYSMPU_EDR_EACD(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_EDR_EACD_SHIFT)) & SYSMPU_EDR_EACD_MASK)
 
#define SYSMPU_EDR_COUNT   (5U)
 
WORD - Region Descriptor n, Word 0..Region Descriptor n, Word 3
#define SYSMPU_WORD_VLD_MASK   (0x1U)
 
#define SYSMPU_WORD_VLD_SHIFT   (0U)
 
#define SYSMPU_WORD_VLD(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_WORD_VLD_SHIFT)) & SYSMPU_WORD_VLD_MASK)
 
#define SYSMPU_WORD_M0UM_MASK   (0x7U)
 
#define SYSMPU_WORD_M0UM_SHIFT   (0U)
 
#define SYSMPU_WORD_M0UM(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_WORD_M0UM_SHIFT)) & SYSMPU_WORD_M0UM_MASK)
 
#define SYSMPU_WORD_M0SM_MASK   (0x18U)
 
#define SYSMPU_WORD_M0SM_SHIFT   (3U)
 
#define SYSMPU_WORD_M0SM(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_WORD_M0SM_SHIFT)) & SYSMPU_WORD_M0SM_MASK)
 
#define SYSMPU_WORD_M0PE_MASK   (0x20U)
 
#define SYSMPU_WORD_M0PE_SHIFT   (5U)
 
#define SYSMPU_WORD_M0PE(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_WORD_M0PE_SHIFT)) & SYSMPU_WORD_M0PE_MASK)
 
#define SYSMPU_WORD_ENDADDR_MASK   (0xFFFFFFE0U)
 
#define SYSMPU_WORD_ENDADDR_SHIFT   (5U)
 
#define SYSMPU_WORD_ENDADDR(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_WORD_ENDADDR_SHIFT)) & SYSMPU_WORD_ENDADDR_MASK)
 
#define SYSMPU_WORD_SRTADDR_MASK   (0xFFFFFFE0U)
 
#define SYSMPU_WORD_SRTADDR_SHIFT   (5U)
 
#define SYSMPU_WORD_SRTADDR(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_WORD_SRTADDR_SHIFT)) & SYSMPU_WORD_SRTADDR_MASK)
 
#define SYSMPU_WORD_M1UM_MASK   (0x1C0U)
 
#define SYSMPU_WORD_M1UM_SHIFT   (6U)
 
#define SYSMPU_WORD_M1UM(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_WORD_M1UM_SHIFT)) & SYSMPU_WORD_M1UM_MASK)
 
#define SYSMPU_WORD_M1SM_MASK   (0x600U)
 
#define SYSMPU_WORD_M1SM_SHIFT   (9U)
 
#define SYSMPU_WORD_M1SM(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_WORD_M1SM_SHIFT)) & SYSMPU_WORD_M1SM_MASK)
 
#define SYSMPU_WORD_M1PE_MASK   (0x800U)
 
#define SYSMPU_WORD_M1PE_SHIFT   (11U)
 
#define SYSMPU_WORD_M1PE(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_WORD_M1PE_SHIFT)) & SYSMPU_WORD_M1PE_MASK)
 
#define SYSMPU_WORD_M2UM_MASK   (0x7000U)
 
#define SYSMPU_WORD_M2UM_SHIFT   (12U)
 
#define SYSMPU_WORD_M2UM(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_WORD_M2UM_SHIFT)) & SYSMPU_WORD_M2UM_MASK)
 
#define SYSMPU_WORD_M2SM_MASK   (0x18000U)
 
#define SYSMPU_WORD_M2SM_SHIFT   (15U)
 
#define SYSMPU_WORD_M2SM(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_WORD_M2SM_SHIFT)) & SYSMPU_WORD_M2SM_MASK)
 
#define SYSMPU_WORD_PIDMASK_MASK   (0xFF0000U)
 
#define SYSMPU_WORD_PIDMASK_SHIFT   (16U)
 
#define SYSMPU_WORD_PIDMASK(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_WORD_PIDMASK_SHIFT)) & SYSMPU_WORD_PIDMASK_MASK)
 
#define SYSMPU_WORD_M2PE_MASK   (0x20000U)
 
#define SYSMPU_WORD_M2PE_SHIFT   (17U)
 
#define SYSMPU_WORD_M2PE(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_WORD_M2PE_SHIFT)) & SYSMPU_WORD_M2PE_MASK)
 
#define SYSMPU_WORD_M3UM_MASK   (0x1C0000U)
 
#define SYSMPU_WORD_M3UM_SHIFT   (18U)
 
#define SYSMPU_WORD_M3UM(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_WORD_M3UM_SHIFT)) & SYSMPU_WORD_M3UM_MASK)
 
#define SYSMPU_WORD_M3SM_MASK   (0x600000U)
 
#define SYSMPU_WORD_M3SM_SHIFT   (21U)
 
#define SYSMPU_WORD_M3SM(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_WORD_M3SM_SHIFT)) & SYSMPU_WORD_M3SM_MASK)
 
#define SYSMPU_WORD_M3PE_MASK   (0x800000U)
 
#define SYSMPU_WORD_M3PE_SHIFT   (23U)
 
#define SYSMPU_WORD_M3PE(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_WORD_M3PE_SHIFT)) & SYSMPU_WORD_M3PE_MASK)
 
#define SYSMPU_WORD_PID_MASK   (0xFF000000U)
 
#define SYSMPU_WORD_PID_SHIFT   (24U)
 
#define SYSMPU_WORD_PID(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_WORD_PID_SHIFT)) & SYSMPU_WORD_PID_MASK)
 
#define SYSMPU_WORD_M4WE_MASK   (0x1000000U)
 
#define SYSMPU_WORD_M4WE_SHIFT   (24U)
 
#define SYSMPU_WORD_M4WE(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_WORD_M4WE_SHIFT)) & SYSMPU_WORD_M4WE_MASK)
 
#define SYSMPU_WORD_M4RE_MASK   (0x2000000U)
 
#define SYSMPU_WORD_M4RE_SHIFT   (25U)
 
#define SYSMPU_WORD_M4RE(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_WORD_M4RE_SHIFT)) & SYSMPU_WORD_M4RE_MASK)
 
#define SYSMPU_WORD_M5WE_MASK   (0x4000000U)
 
#define SYSMPU_WORD_M5WE_SHIFT   (26U)
 
#define SYSMPU_WORD_M5WE(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_WORD_M5WE_SHIFT)) & SYSMPU_WORD_M5WE_MASK)
 
#define SYSMPU_WORD_M5RE_MASK   (0x8000000U)
 
#define SYSMPU_WORD_M5RE_SHIFT   (27U)
 
#define SYSMPU_WORD_M5RE(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_WORD_M5RE_SHIFT)) & SYSMPU_WORD_M5RE_MASK)
 
#define SYSMPU_WORD_M6WE_MASK   (0x10000000U)
 
#define SYSMPU_WORD_M6WE_SHIFT   (28U)
 
#define SYSMPU_WORD_M6WE(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_WORD_M6WE_SHIFT)) & SYSMPU_WORD_M6WE_MASK)
 
#define SYSMPU_WORD_M6RE_MASK   (0x20000000U)
 
#define SYSMPU_WORD_M6RE_SHIFT   (29U)
 
#define SYSMPU_WORD_M6RE(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_WORD_M6RE_SHIFT)) & SYSMPU_WORD_M6RE_MASK)
 
#define SYSMPU_WORD_M7WE_MASK   (0x40000000U)
 
#define SYSMPU_WORD_M7WE_SHIFT   (30U)
 
#define SYSMPU_WORD_M7WE(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_WORD_M7WE_SHIFT)) & SYSMPU_WORD_M7WE_MASK)
 
#define SYSMPU_WORD_M7RE_MASK   (0x80000000U)
 
#define SYSMPU_WORD_M7RE_SHIFT   (31U)
 
#define SYSMPU_WORD_M7RE(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_WORD_M7RE_SHIFT)) & SYSMPU_WORD_M7RE_MASK)
 
#define SYSMPU_WORD_COUNT   (12U)
 
#define SYSMPU_WORD_COUNT2   (4U)
 
RGDAAC - Region Descriptor Alternate Access Control n
#define SYSMPU_RGDAAC_M0UM_MASK   (0x7U)
 
#define SYSMPU_RGDAAC_M0UM_SHIFT   (0U)
 
#define SYSMPU_RGDAAC_M0UM(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_RGDAAC_M0UM_SHIFT)) & SYSMPU_RGDAAC_M0UM_MASK)
 
#define SYSMPU_RGDAAC_M0SM_MASK   (0x18U)
 
#define SYSMPU_RGDAAC_M0SM_SHIFT   (3U)
 
#define SYSMPU_RGDAAC_M0SM(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_RGDAAC_M0SM_SHIFT)) & SYSMPU_RGDAAC_M0SM_MASK)
 
#define SYSMPU_RGDAAC_M0PE_MASK   (0x20U)
 
#define SYSMPU_RGDAAC_M0PE_SHIFT   (5U)
 
#define SYSMPU_RGDAAC_M0PE(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_RGDAAC_M0PE_SHIFT)) & SYSMPU_RGDAAC_M0PE_MASK)
 
#define SYSMPU_RGDAAC_M1UM_MASK   (0x1C0U)
 
#define SYSMPU_RGDAAC_M1UM_SHIFT   (6U)
 
#define SYSMPU_RGDAAC_M1UM(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_RGDAAC_M1UM_SHIFT)) & SYSMPU_RGDAAC_M1UM_MASK)
 
#define SYSMPU_RGDAAC_M1SM_MASK   (0x600U)
 
#define SYSMPU_RGDAAC_M1SM_SHIFT   (9U)
 
#define SYSMPU_RGDAAC_M1SM(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_RGDAAC_M1SM_SHIFT)) & SYSMPU_RGDAAC_M1SM_MASK)
 
#define SYSMPU_RGDAAC_M1PE_MASK   (0x800U)
 
#define SYSMPU_RGDAAC_M1PE_SHIFT   (11U)
 
#define SYSMPU_RGDAAC_M1PE(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_RGDAAC_M1PE_SHIFT)) & SYSMPU_RGDAAC_M1PE_MASK)
 
#define SYSMPU_RGDAAC_M2UM_MASK   (0x7000U)
 
#define SYSMPU_RGDAAC_M2UM_SHIFT   (12U)
 
#define SYSMPU_RGDAAC_M2UM(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_RGDAAC_M2UM_SHIFT)) & SYSMPU_RGDAAC_M2UM_MASK)
 
#define SYSMPU_RGDAAC_M2SM_MASK   (0x18000U)
 
#define SYSMPU_RGDAAC_M2SM_SHIFT   (15U)
 
#define SYSMPU_RGDAAC_M2SM(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_RGDAAC_M2SM_SHIFT)) & SYSMPU_RGDAAC_M2SM_MASK)
 
#define SYSMPU_RGDAAC_M2PE_MASK   (0x20000U)
 
#define SYSMPU_RGDAAC_M2PE_SHIFT   (17U)
 
#define SYSMPU_RGDAAC_M2PE(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_RGDAAC_M2PE_SHIFT)) & SYSMPU_RGDAAC_M2PE_MASK)
 
#define SYSMPU_RGDAAC_M3UM_MASK   (0x1C0000U)
 
#define SYSMPU_RGDAAC_M3UM_SHIFT   (18U)
 
#define SYSMPU_RGDAAC_M3UM(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_RGDAAC_M3UM_SHIFT)) & SYSMPU_RGDAAC_M3UM_MASK)
 
#define SYSMPU_RGDAAC_M3SM_MASK   (0x600000U)
 
#define SYSMPU_RGDAAC_M3SM_SHIFT   (21U)
 
#define SYSMPU_RGDAAC_M3SM(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_RGDAAC_M3SM_SHIFT)) & SYSMPU_RGDAAC_M3SM_MASK)
 
#define SYSMPU_RGDAAC_M3PE_MASK   (0x800000U)
 
#define SYSMPU_RGDAAC_M3PE_SHIFT   (23U)
 
#define SYSMPU_RGDAAC_M3PE(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_RGDAAC_M3PE_SHIFT)) & SYSMPU_RGDAAC_M3PE_MASK)
 
#define SYSMPU_RGDAAC_M4WE_MASK   (0x1000000U)
 
#define SYSMPU_RGDAAC_M4WE_SHIFT   (24U)
 
#define SYSMPU_RGDAAC_M4WE(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_RGDAAC_M4WE_SHIFT)) & SYSMPU_RGDAAC_M4WE_MASK)
 
#define SYSMPU_RGDAAC_M4RE_MASK   (0x2000000U)
 
#define SYSMPU_RGDAAC_M4RE_SHIFT   (25U)
 
#define SYSMPU_RGDAAC_M4RE(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_RGDAAC_M4RE_SHIFT)) & SYSMPU_RGDAAC_M4RE_MASK)
 
#define SYSMPU_RGDAAC_M5WE_MASK   (0x4000000U)
 
#define SYSMPU_RGDAAC_M5WE_SHIFT   (26U)
 
#define SYSMPU_RGDAAC_M5WE(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_RGDAAC_M5WE_SHIFT)) & SYSMPU_RGDAAC_M5WE_MASK)
 
#define SYSMPU_RGDAAC_M5RE_MASK   (0x8000000U)
 
#define SYSMPU_RGDAAC_M5RE_SHIFT   (27U)
 
#define SYSMPU_RGDAAC_M5RE(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_RGDAAC_M5RE_SHIFT)) & SYSMPU_RGDAAC_M5RE_MASK)
 
#define SYSMPU_RGDAAC_M6WE_MASK   (0x10000000U)
 
#define SYSMPU_RGDAAC_M6WE_SHIFT   (28U)
 
#define SYSMPU_RGDAAC_M6WE(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_RGDAAC_M6WE_SHIFT)) & SYSMPU_RGDAAC_M6WE_MASK)
 
#define SYSMPU_RGDAAC_M6RE_MASK   (0x20000000U)
 
#define SYSMPU_RGDAAC_M6RE_SHIFT   (29U)
 
#define SYSMPU_RGDAAC_M6RE(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_RGDAAC_M6RE_SHIFT)) & SYSMPU_RGDAAC_M6RE_MASK)
 
#define SYSMPU_RGDAAC_M7WE_MASK   (0x40000000U)
 
#define SYSMPU_RGDAAC_M7WE_SHIFT   (30U)
 
#define SYSMPU_RGDAAC_M7WE(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_RGDAAC_M7WE_SHIFT)) & SYSMPU_RGDAAC_M7WE_MASK)
 
#define SYSMPU_RGDAAC_M7RE_MASK   (0x80000000U)
 
#define SYSMPU_RGDAAC_M7RE_SHIFT   (31U)
 
#define SYSMPU_RGDAAC_M7RE(x)   (((uint32_t)(((uint32_t)(x)) << SYSMPU_RGDAAC_M7RE_SHIFT)) & SYSMPU_RGDAAC_M7RE_MASK)
 
#define SYSMPU_RGDAAC_COUNT   (12U)
 
BDH - UART Baud Rate Registers: High
#define UART_BDH_SBR_MASK   (0x1FU)
 
#define UART_BDH_SBR_SHIFT   (0U)
 
#define UART_BDH_SBR(x)   (((uint8_t)(((uint8_t)(x)) << UART_BDH_SBR_SHIFT)) & UART_BDH_SBR_MASK)
 
#define UART_BDH_SBNS_MASK   (0x20U)
 
#define UART_BDH_SBNS_SHIFT   (5U)
 
#define UART_BDH_SBNS(x)   (((uint8_t)(((uint8_t)(x)) << UART_BDH_SBNS_SHIFT)) & UART_BDH_SBNS_MASK)
 
#define UART_BDH_RXEDGIE_MASK   (0x40U)
 
#define UART_BDH_RXEDGIE_SHIFT   (6U)
 
#define UART_BDH_RXEDGIE(x)   (((uint8_t)(((uint8_t)(x)) << UART_BDH_RXEDGIE_SHIFT)) & UART_BDH_RXEDGIE_MASK)
 
#define UART_BDH_LBKDIE_MASK   (0x80U)
 
#define UART_BDH_LBKDIE_SHIFT   (7U)
 
#define UART_BDH_LBKDIE(x)   (((uint8_t)(((uint8_t)(x)) << UART_BDH_LBKDIE_SHIFT)) & UART_BDH_LBKDIE_MASK)
 
BDL - UART Baud Rate Registers: Low
#define UART_BDL_SBR_MASK   (0xFFU)
 
#define UART_BDL_SBR_SHIFT   (0U)
 
#define UART_BDL_SBR(x)   (((uint8_t)(((uint8_t)(x)) << UART_BDL_SBR_SHIFT)) & UART_BDL_SBR_MASK)
 
C1 - UART Control Register 1
#define UART_C1_PT_MASK   (0x1U)
 
#define UART_C1_PT_SHIFT   (0U)
 
#define UART_C1_PT(x)   (((uint8_t)(((uint8_t)(x)) << UART_C1_PT_SHIFT)) & UART_C1_PT_MASK)
 
#define UART_C1_PE_MASK   (0x2U)
 
#define UART_C1_PE_SHIFT   (1U)
 
#define UART_C1_PE(x)   (((uint8_t)(((uint8_t)(x)) << UART_C1_PE_SHIFT)) & UART_C1_PE_MASK)
 
#define UART_C1_ILT_MASK   (0x4U)
 
#define UART_C1_ILT_SHIFT   (2U)
 
#define UART_C1_ILT(x)   (((uint8_t)(((uint8_t)(x)) << UART_C1_ILT_SHIFT)) & UART_C1_ILT_MASK)
 
#define UART_C1_WAKE_MASK   (0x8U)
 
#define UART_C1_WAKE_SHIFT   (3U)
 
#define UART_C1_WAKE(x)   (((uint8_t)(((uint8_t)(x)) << UART_C1_WAKE_SHIFT)) & UART_C1_WAKE_MASK)
 
#define UART_C1_M_MASK   (0x10U)
 
#define UART_C1_M_SHIFT   (4U)
 
#define UART_C1_M(x)   (((uint8_t)(((uint8_t)(x)) << UART_C1_M_SHIFT)) & UART_C1_M_MASK)
 
#define UART_C1_RSRC_MASK   (0x20U)
 
#define UART_C1_RSRC_SHIFT   (5U)
 
#define UART_C1_RSRC(x)   (((uint8_t)(((uint8_t)(x)) << UART_C1_RSRC_SHIFT)) & UART_C1_RSRC_MASK)
 
#define UART_C1_UARTSWAI_MASK   (0x40U)
 
#define UART_C1_UARTSWAI_SHIFT   (6U)
 
#define UART_C1_UARTSWAI(x)   (((uint8_t)(((uint8_t)(x)) << UART_C1_UARTSWAI_SHIFT)) & UART_C1_UARTSWAI_MASK)
 
#define UART_C1_LOOPS_MASK   (0x80U)
 
#define UART_C1_LOOPS_SHIFT   (7U)
 
#define UART_C1_LOOPS(x)   (((uint8_t)(((uint8_t)(x)) << UART_C1_LOOPS_SHIFT)) & UART_C1_LOOPS_MASK)
 
C2 - UART Control Register 2
#define UART_C2_SBK_MASK   (0x1U)
 
#define UART_C2_SBK_SHIFT   (0U)
 
#define UART_C2_SBK(x)   (((uint8_t)(((uint8_t)(x)) << UART_C2_SBK_SHIFT)) & UART_C2_SBK_MASK)
 
#define UART_C2_RWU_MASK   (0x2U)
 
#define UART_C2_RWU_SHIFT   (1U)
 
#define UART_C2_RWU(x)   (((uint8_t)(((uint8_t)(x)) << UART_C2_RWU_SHIFT)) & UART_C2_RWU_MASK)
 
#define UART_C2_RE_MASK   (0x4U)
 
#define UART_C2_RE_SHIFT   (2U)
 
#define UART_C2_RE(x)   (((uint8_t)(((uint8_t)(x)) << UART_C2_RE_SHIFT)) & UART_C2_RE_MASK)
 
#define UART_C2_TE_MASK   (0x8U)
 
#define UART_C2_TE_SHIFT   (3U)
 
#define UART_C2_TE(x)   (((uint8_t)(((uint8_t)(x)) << UART_C2_TE_SHIFT)) & UART_C2_TE_MASK)
 
#define UART_C2_ILIE_MASK   (0x10U)
 
#define UART_C2_ILIE_SHIFT   (4U)
 
#define UART_C2_ILIE(x)   (((uint8_t)(((uint8_t)(x)) << UART_C2_ILIE_SHIFT)) & UART_C2_ILIE_MASK)
 
#define UART_C2_RIE_MASK   (0x20U)
 
#define UART_C2_RIE_SHIFT   (5U)
 
#define UART_C2_RIE(x)   (((uint8_t)(((uint8_t)(x)) << UART_C2_RIE_SHIFT)) & UART_C2_RIE_MASK)
 
#define UART_C2_TCIE_MASK   (0x40U)
 
#define UART_C2_TCIE_SHIFT   (6U)
 
#define UART_C2_TCIE(x)   (((uint8_t)(((uint8_t)(x)) << UART_C2_TCIE_SHIFT)) & UART_C2_TCIE_MASK)
 
#define UART_C2_TIE_MASK   (0x80U)
 
#define UART_C2_TIE_SHIFT   (7U)
 
#define UART_C2_TIE(x)   (((uint8_t)(((uint8_t)(x)) << UART_C2_TIE_SHIFT)) & UART_C2_TIE_MASK)
 
S1 - UART Status Register 1
#define UART_S1_PF_MASK   (0x1U)
 
#define UART_S1_PF_SHIFT   (0U)
 
#define UART_S1_PF(x)   (((uint8_t)(((uint8_t)(x)) << UART_S1_PF_SHIFT)) & UART_S1_PF_MASK)
 
#define UART_S1_FE_MASK   (0x2U)
 
#define UART_S1_FE_SHIFT   (1U)
 
#define UART_S1_FE(x)   (((uint8_t)(((uint8_t)(x)) << UART_S1_FE_SHIFT)) & UART_S1_FE_MASK)
 
#define UART_S1_NF_MASK   (0x4U)
 
#define UART_S1_NF_SHIFT   (2U)
 
#define UART_S1_NF(x)   (((uint8_t)(((uint8_t)(x)) << UART_S1_NF_SHIFT)) & UART_S1_NF_MASK)
 
#define UART_S1_OR_MASK   (0x8U)
 
#define UART_S1_OR_SHIFT   (3U)
 
#define UART_S1_OR(x)   (((uint8_t)(((uint8_t)(x)) << UART_S1_OR_SHIFT)) & UART_S1_OR_MASK)
 
#define UART_S1_IDLE_MASK   (0x10U)
 
#define UART_S1_IDLE_SHIFT   (4U)
 
#define UART_S1_IDLE(x)   (((uint8_t)(((uint8_t)(x)) << UART_S1_IDLE_SHIFT)) & UART_S1_IDLE_MASK)
 
#define UART_S1_RDRF_MASK   (0x20U)
 
#define UART_S1_RDRF_SHIFT   (5U)
 
#define UART_S1_RDRF(x)   (((uint8_t)(((uint8_t)(x)) << UART_S1_RDRF_SHIFT)) & UART_S1_RDRF_MASK)
 
#define UART_S1_TC_MASK   (0x40U)
 
#define UART_S1_TC_SHIFT   (6U)
 
#define UART_S1_TC(x)   (((uint8_t)(((uint8_t)(x)) << UART_S1_TC_SHIFT)) & UART_S1_TC_MASK)
 
#define UART_S1_TDRE_MASK   (0x80U)
 
#define UART_S1_TDRE_SHIFT   (7U)
 
#define UART_S1_TDRE(x)   (((uint8_t)(((uint8_t)(x)) << UART_S1_TDRE_SHIFT)) & UART_S1_TDRE_MASK)
 
S2 - UART Status Register 2
#define UART_S2_RAF_MASK   (0x1U)
 
#define UART_S2_RAF_SHIFT   (0U)
 
#define UART_S2_RAF(x)   (((uint8_t)(((uint8_t)(x)) << UART_S2_RAF_SHIFT)) & UART_S2_RAF_MASK)
 
#define UART_S2_LBKDE_MASK   (0x2U)
 
#define UART_S2_LBKDE_SHIFT   (1U)
 
#define UART_S2_LBKDE(x)   (((uint8_t)(((uint8_t)(x)) << UART_S2_LBKDE_SHIFT)) & UART_S2_LBKDE_MASK)
 
#define UART_S2_BRK13_MASK   (0x4U)
 
#define UART_S2_BRK13_SHIFT   (2U)
 
#define UART_S2_BRK13(x)   (((uint8_t)(((uint8_t)(x)) << UART_S2_BRK13_SHIFT)) & UART_S2_BRK13_MASK)
 
#define UART_S2_RWUID_MASK   (0x8U)
 
#define UART_S2_RWUID_SHIFT   (3U)
 
#define UART_S2_RWUID(x)   (((uint8_t)(((uint8_t)(x)) << UART_S2_RWUID_SHIFT)) & UART_S2_RWUID_MASK)
 
#define UART_S2_RXINV_MASK   (0x10U)
 
#define UART_S2_RXINV_SHIFT   (4U)
 
#define UART_S2_RXINV(x)   (((uint8_t)(((uint8_t)(x)) << UART_S2_RXINV_SHIFT)) & UART_S2_RXINV_MASK)
 
#define UART_S2_MSBF_MASK   (0x20U)
 
#define UART_S2_MSBF_SHIFT   (5U)
 
#define UART_S2_MSBF(x)   (((uint8_t)(((uint8_t)(x)) << UART_S2_MSBF_SHIFT)) & UART_S2_MSBF_MASK)
 
#define UART_S2_RXEDGIF_MASK   (0x40U)
 
#define UART_S2_RXEDGIF_SHIFT   (6U)
 
#define UART_S2_RXEDGIF(x)   (((uint8_t)(((uint8_t)(x)) << UART_S2_RXEDGIF_SHIFT)) & UART_S2_RXEDGIF_MASK)
 
#define UART_S2_LBKDIF_MASK   (0x80U)
 
#define UART_S2_LBKDIF_SHIFT   (7U)
 
#define UART_S2_LBKDIF(x)   (((uint8_t)(((uint8_t)(x)) << UART_S2_LBKDIF_SHIFT)) & UART_S2_LBKDIF_MASK)
 
C3 - UART Control Register 3
#define UART_C3_PEIE_MASK   (0x1U)
 
#define UART_C3_PEIE_SHIFT   (0U)
 
#define UART_C3_PEIE(x)   (((uint8_t)(((uint8_t)(x)) << UART_C3_PEIE_SHIFT)) & UART_C3_PEIE_MASK)
 
#define UART_C3_FEIE_MASK   (0x2U)
 
#define UART_C3_FEIE_SHIFT   (1U)
 
#define UART_C3_FEIE(x)   (((uint8_t)(((uint8_t)(x)) << UART_C3_FEIE_SHIFT)) & UART_C3_FEIE_MASK)
 
#define UART_C3_NEIE_MASK   (0x4U)
 
#define UART_C3_NEIE_SHIFT   (2U)
 
#define UART_C3_NEIE(x)   (((uint8_t)(((uint8_t)(x)) << UART_C3_NEIE_SHIFT)) & UART_C3_NEIE_MASK)
 
#define UART_C3_ORIE_MASK   (0x8U)
 
#define UART_C3_ORIE_SHIFT   (3U)
 
#define UART_C3_ORIE(x)   (((uint8_t)(((uint8_t)(x)) << UART_C3_ORIE_SHIFT)) & UART_C3_ORIE_MASK)
 
#define UART_C3_TXINV_MASK   (0x10U)
 
#define UART_C3_TXINV_SHIFT   (4U)
 
#define UART_C3_TXINV(x)   (((uint8_t)(((uint8_t)(x)) << UART_C3_TXINV_SHIFT)) & UART_C3_TXINV_MASK)
 
#define UART_C3_TXDIR_MASK   (0x20U)
 
#define UART_C3_TXDIR_SHIFT   (5U)
 
#define UART_C3_TXDIR(x)   (((uint8_t)(((uint8_t)(x)) << UART_C3_TXDIR_SHIFT)) & UART_C3_TXDIR_MASK)
 
#define UART_C3_T8_MASK   (0x40U)
 
#define UART_C3_T8_SHIFT   (6U)
 
#define UART_C3_T8(x)   (((uint8_t)(((uint8_t)(x)) << UART_C3_T8_SHIFT)) & UART_C3_T8_MASK)
 
#define UART_C3_R8_MASK   (0x80U)
 
#define UART_C3_R8_SHIFT   (7U)
 
#define UART_C3_R8(x)   (((uint8_t)(((uint8_t)(x)) << UART_C3_R8_SHIFT)) & UART_C3_R8_MASK)
 
D - UART Data Register
#define UART_D_RT_MASK   (0xFFU)
 
#define UART_D_RT_SHIFT   (0U)
 
#define UART_D_RT(x)   (((uint8_t)(((uint8_t)(x)) << UART_D_RT_SHIFT)) & UART_D_RT_MASK)
 
MA1 - UART Match Address Registers 1
#define UART_MA1_MA_MASK   (0xFFU)
 
#define UART_MA1_MA_SHIFT   (0U)
 
#define UART_MA1_MA(x)   (((uint8_t)(((uint8_t)(x)) << UART_MA1_MA_SHIFT)) & UART_MA1_MA_MASK)
 
MA2 - UART Match Address Registers 2
#define UART_MA2_MA_MASK   (0xFFU)
 
#define UART_MA2_MA_SHIFT   (0U)
 
#define UART_MA2_MA(x)   (((uint8_t)(((uint8_t)(x)) << UART_MA2_MA_SHIFT)) & UART_MA2_MA_MASK)
 
C4 - UART Control Register 4
#define UART_C4_BRFA_MASK   (0x1FU)
 
#define UART_C4_BRFA_SHIFT   (0U)
 
#define UART_C4_BRFA(x)   (((uint8_t)(((uint8_t)(x)) << UART_C4_BRFA_SHIFT)) & UART_C4_BRFA_MASK)
 
#define UART_C4_M10_MASK   (0x20U)
 
#define UART_C4_M10_SHIFT   (5U)
 
#define UART_C4_M10(x)   (((uint8_t)(((uint8_t)(x)) << UART_C4_M10_SHIFT)) & UART_C4_M10_MASK)
 
#define UART_C4_MAEN2_MASK   (0x40U)
 
#define UART_C4_MAEN2_SHIFT   (6U)
 
#define UART_C4_MAEN2(x)   (((uint8_t)(((uint8_t)(x)) << UART_C4_MAEN2_SHIFT)) & UART_C4_MAEN2_MASK)
 
#define UART_C4_MAEN1_MASK   (0x80U)
 
#define UART_C4_MAEN1_SHIFT   (7U)
 
#define UART_C4_MAEN1(x)   (((uint8_t)(((uint8_t)(x)) << UART_C4_MAEN1_SHIFT)) & UART_C4_MAEN1_MASK)
 
C5 - UART Control Register 5
#define UART_C5_LBKDDMAS_MASK   (0x8U)
 
#define UART_C5_LBKDDMAS_SHIFT   (3U)
 
#define UART_C5_LBKDDMAS(x)   (((uint8_t)(((uint8_t)(x)) << UART_C5_LBKDDMAS_SHIFT)) & UART_C5_LBKDDMAS_MASK)
 
#define UART_C5_ILDMAS_MASK   (0x10U)
 
#define UART_C5_ILDMAS_SHIFT   (4U)
 
#define UART_C5_ILDMAS(x)   (((uint8_t)(((uint8_t)(x)) << UART_C5_ILDMAS_SHIFT)) & UART_C5_ILDMAS_MASK)
 
#define UART_C5_RDMAS_MASK   (0x20U)
 
#define UART_C5_RDMAS_SHIFT   (5U)
 
#define UART_C5_RDMAS(x)   (((uint8_t)(((uint8_t)(x)) << UART_C5_RDMAS_SHIFT)) & UART_C5_RDMAS_MASK)
 
#define UART_C5_TCDMAS_MASK   (0x40U)
 
#define UART_C5_TCDMAS_SHIFT   (6U)
 
#define UART_C5_TCDMAS(x)   (((uint8_t)(((uint8_t)(x)) << UART_C5_TCDMAS_SHIFT)) & UART_C5_TCDMAS_MASK)
 
#define UART_C5_TDMAS_MASK   (0x80U)
 
#define UART_C5_TDMAS_SHIFT   (7U)
 
#define UART_C5_TDMAS(x)   (((uint8_t)(((uint8_t)(x)) << UART_C5_TDMAS_SHIFT)) & UART_C5_TDMAS_MASK)
 
ED - UART Extended Data Register
#define UART_ED_PARITYE_MASK   (0x40U)
 
#define UART_ED_PARITYE_SHIFT   (6U)
 
#define UART_ED_PARITYE(x)   (((uint8_t)(((uint8_t)(x)) << UART_ED_PARITYE_SHIFT)) & UART_ED_PARITYE_MASK)
 
#define UART_ED_NOISY_MASK   (0x80U)
 
#define UART_ED_NOISY_SHIFT   (7U)
 
#define UART_ED_NOISY(x)   (((uint8_t)(((uint8_t)(x)) << UART_ED_NOISY_SHIFT)) & UART_ED_NOISY_MASK)
 
MODEM - UART Modem Register
#define UART_MODEM_TXCTSE_MASK   (0x1U)
 
#define UART_MODEM_TXCTSE_SHIFT   (0U)
 
#define UART_MODEM_TXCTSE(x)   (((uint8_t)(((uint8_t)(x)) << UART_MODEM_TXCTSE_SHIFT)) & UART_MODEM_TXCTSE_MASK)
 
#define UART_MODEM_TXRTSE_MASK   (0x2U)
 
#define UART_MODEM_TXRTSE_SHIFT   (1U)
 
#define UART_MODEM_TXRTSE(x)   (((uint8_t)(((uint8_t)(x)) << UART_MODEM_TXRTSE_SHIFT)) & UART_MODEM_TXRTSE_MASK)
 
#define UART_MODEM_TXRTSPOL_MASK   (0x4U)
 
#define UART_MODEM_TXRTSPOL_SHIFT   (2U)
 
#define UART_MODEM_TXRTSPOL(x)   (((uint8_t)(((uint8_t)(x)) << UART_MODEM_TXRTSPOL_SHIFT)) & UART_MODEM_TXRTSPOL_MASK)
 
#define UART_MODEM_RXRTSE_MASK   (0x8U)
 
#define UART_MODEM_RXRTSE_SHIFT   (3U)
 
#define UART_MODEM_RXRTSE(x)   (((uint8_t)(((uint8_t)(x)) << UART_MODEM_RXRTSE_SHIFT)) & UART_MODEM_RXRTSE_MASK)
 
IR - UART Infrared Register
#define UART_IR_TNP_MASK   (0x3U)
 
#define UART_IR_TNP_SHIFT   (0U)
 
#define UART_IR_TNP(x)   (((uint8_t)(((uint8_t)(x)) << UART_IR_TNP_SHIFT)) & UART_IR_TNP_MASK)
 
#define UART_IR_IREN_MASK   (0x4U)
 
#define UART_IR_IREN_SHIFT   (2U)
 
#define UART_IR_IREN(x)   (((uint8_t)(((uint8_t)(x)) << UART_IR_IREN_SHIFT)) & UART_IR_IREN_MASK)
 
PFIFO - UART FIFO Parameters
#define UART_PFIFO_RXFIFOSIZE_MASK   (0x7U)
 
#define UART_PFIFO_RXFIFOSIZE_SHIFT   (0U)
 
#define UART_PFIFO_RXFIFOSIZE(x)   (((uint8_t)(((uint8_t)(x)) << UART_PFIFO_RXFIFOSIZE_SHIFT)) & UART_PFIFO_RXFIFOSIZE_MASK)
 
#define UART_PFIFO_RXFE_MASK   (0x8U)
 
#define UART_PFIFO_RXFE_SHIFT   (3U)
 
#define UART_PFIFO_RXFE(x)   (((uint8_t)(((uint8_t)(x)) << UART_PFIFO_RXFE_SHIFT)) & UART_PFIFO_RXFE_MASK)
 
#define UART_PFIFO_TXFIFOSIZE_MASK   (0x70U)
 
#define UART_PFIFO_TXFIFOSIZE_SHIFT   (4U)
 
#define UART_PFIFO_TXFIFOSIZE(x)   (((uint8_t)(((uint8_t)(x)) << UART_PFIFO_TXFIFOSIZE_SHIFT)) & UART_PFIFO_TXFIFOSIZE_MASK)
 
#define UART_PFIFO_TXFE_MASK   (0x80U)
 
#define UART_PFIFO_TXFE_SHIFT   (7U)
 
#define UART_PFIFO_TXFE(x)   (((uint8_t)(((uint8_t)(x)) << UART_PFIFO_TXFE_SHIFT)) & UART_PFIFO_TXFE_MASK)
 
CFIFO - UART FIFO Control Register
#define UART_CFIFO_RXUFE_MASK   (0x1U)
 
#define UART_CFIFO_RXUFE_SHIFT   (0U)
 
#define UART_CFIFO_RXUFE(x)   (((uint8_t)(((uint8_t)(x)) << UART_CFIFO_RXUFE_SHIFT)) & UART_CFIFO_RXUFE_MASK)
 
#define UART_CFIFO_TXOFE_MASK   (0x2U)
 
#define UART_CFIFO_TXOFE_SHIFT   (1U)
 
#define UART_CFIFO_TXOFE(x)   (((uint8_t)(((uint8_t)(x)) << UART_CFIFO_TXOFE_SHIFT)) & UART_CFIFO_TXOFE_MASK)
 
#define UART_CFIFO_RXOFE_MASK   (0x4U)
 
#define UART_CFIFO_RXOFE_SHIFT   (2U)
 
#define UART_CFIFO_RXOFE(x)   (((uint8_t)(((uint8_t)(x)) << UART_CFIFO_RXOFE_SHIFT)) & UART_CFIFO_RXOFE_MASK)
 
#define UART_CFIFO_RXFLUSH_MASK   (0x40U)
 
#define UART_CFIFO_RXFLUSH_SHIFT   (6U)
 
#define UART_CFIFO_RXFLUSH(x)   (((uint8_t)(((uint8_t)(x)) << UART_CFIFO_RXFLUSH_SHIFT)) & UART_CFIFO_RXFLUSH_MASK)
 
#define UART_CFIFO_TXFLUSH_MASK   (0x80U)
 
#define UART_CFIFO_TXFLUSH_SHIFT   (7U)
 
#define UART_CFIFO_TXFLUSH(x)   (((uint8_t)(((uint8_t)(x)) << UART_CFIFO_TXFLUSH_SHIFT)) & UART_CFIFO_TXFLUSH_MASK)
 
SFIFO - UART FIFO Status Register
#define UART_SFIFO_RXUF_MASK   (0x1U)
 
#define UART_SFIFO_RXUF_SHIFT   (0U)
 
#define UART_SFIFO_RXUF(x)   (((uint8_t)(((uint8_t)(x)) << UART_SFIFO_RXUF_SHIFT)) & UART_SFIFO_RXUF_MASK)
 
#define UART_SFIFO_TXOF_MASK   (0x2U)
 
#define UART_SFIFO_TXOF_SHIFT   (1U)
 
#define UART_SFIFO_TXOF(x)   (((uint8_t)(((uint8_t)(x)) << UART_SFIFO_TXOF_SHIFT)) & UART_SFIFO_TXOF_MASK)
 
#define UART_SFIFO_RXOF_MASK   (0x4U)
 
#define UART_SFIFO_RXOF_SHIFT   (2U)
 
#define UART_SFIFO_RXOF(x)   (((uint8_t)(((uint8_t)(x)) << UART_SFIFO_RXOF_SHIFT)) & UART_SFIFO_RXOF_MASK)
 
#define UART_SFIFO_RXEMPT_MASK   (0x40U)
 
#define UART_SFIFO_RXEMPT_SHIFT   (6U)
 
#define UART_SFIFO_RXEMPT(x)   (((uint8_t)(((uint8_t)(x)) << UART_SFIFO_RXEMPT_SHIFT)) & UART_SFIFO_RXEMPT_MASK)
 
#define UART_SFIFO_TXEMPT_MASK   (0x80U)
 
#define UART_SFIFO_TXEMPT_SHIFT   (7U)
 
#define UART_SFIFO_TXEMPT(x)   (((uint8_t)(((uint8_t)(x)) << UART_SFIFO_TXEMPT_SHIFT)) & UART_SFIFO_TXEMPT_MASK)
 
TWFIFO - UART FIFO Transmit Watermark
#define UART_TWFIFO_TXWATER_MASK   (0xFFU)
 
#define UART_TWFIFO_TXWATER_SHIFT   (0U)
 
#define UART_TWFIFO_TXWATER(x)   (((uint8_t)(((uint8_t)(x)) << UART_TWFIFO_TXWATER_SHIFT)) & UART_TWFIFO_TXWATER_MASK)
 
TCFIFO - UART FIFO Transmit Count
#define UART_TCFIFO_TXCOUNT_MASK   (0xFFU)
 
#define UART_TCFIFO_TXCOUNT_SHIFT   (0U)
 
#define UART_TCFIFO_TXCOUNT(x)   (((uint8_t)(((uint8_t)(x)) << UART_TCFIFO_TXCOUNT_SHIFT)) & UART_TCFIFO_TXCOUNT_MASK)
 
RWFIFO - UART FIFO Receive Watermark
#define UART_RWFIFO_RXWATER_MASK   (0xFFU)
 
#define UART_RWFIFO_RXWATER_SHIFT   (0U)
 
#define UART_RWFIFO_RXWATER(x)   (((uint8_t)(((uint8_t)(x)) << UART_RWFIFO_RXWATER_SHIFT)) & UART_RWFIFO_RXWATER_MASK)
 
RCFIFO - UART FIFO Receive Count
#define UART_RCFIFO_RXCOUNT_MASK   (0xFFU)
 
#define UART_RCFIFO_RXCOUNT_SHIFT   (0U)
 
#define UART_RCFIFO_RXCOUNT(x)   (((uint8_t)(((uint8_t)(x)) << UART_RCFIFO_RXCOUNT_SHIFT)) & UART_RCFIFO_RXCOUNT_MASK)
 
C7816 - UART 7816 Control Register
#define UART_C7816_ISO_7816E_MASK   (0x1U)
 
#define UART_C7816_ISO_7816E_SHIFT   (0U)
 
#define UART_C7816_ISO_7816E(x)   (((uint8_t)(((uint8_t)(x)) << UART_C7816_ISO_7816E_SHIFT)) & UART_C7816_ISO_7816E_MASK)
 
#define UART_C7816_TTYPE_MASK   (0x2U)
 
#define UART_C7816_TTYPE_SHIFT   (1U)
 
#define UART_C7816_TTYPE(x)   (((uint8_t)(((uint8_t)(x)) << UART_C7816_TTYPE_SHIFT)) & UART_C7816_TTYPE_MASK)
 
#define UART_C7816_INIT_MASK   (0x4U)
 
#define UART_C7816_INIT_SHIFT   (2U)
 
#define UART_C7816_INIT(x)   (((uint8_t)(((uint8_t)(x)) << UART_C7816_INIT_SHIFT)) & UART_C7816_INIT_MASK)
 
#define UART_C7816_ANACK_MASK   (0x8U)
 
#define UART_C7816_ANACK_SHIFT   (3U)
 
#define UART_C7816_ANACK(x)   (((uint8_t)(((uint8_t)(x)) << UART_C7816_ANACK_SHIFT)) & UART_C7816_ANACK_MASK)
 
#define UART_C7816_ONACK_MASK   (0x10U)
 
#define UART_C7816_ONACK_SHIFT   (4U)
 
#define UART_C7816_ONACK(x)   (((uint8_t)(((uint8_t)(x)) << UART_C7816_ONACK_SHIFT)) & UART_C7816_ONACK_MASK)
 
IE7816 - UART 7816 Interrupt Enable Register
#define UART_IE7816_RXTE_MASK   (0x1U)
 
#define UART_IE7816_RXTE_SHIFT   (0U)
 
#define UART_IE7816_RXTE(x)   (((uint8_t)(((uint8_t)(x)) << UART_IE7816_RXTE_SHIFT)) & UART_IE7816_RXTE_MASK)
 
#define UART_IE7816_TXTE_MASK   (0x2U)
 
#define UART_IE7816_TXTE_SHIFT   (1U)
 
#define UART_IE7816_TXTE(x)   (((uint8_t)(((uint8_t)(x)) << UART_IE7816_TXTE_SHIFT)) & UART_IE7816_TXTE_MASK)
 
#define UART_IE7816_GTVE_MASK   (0x4U)
 
#define UART_IE7816_GTVE_SHIFT   (2U)
 
#define UART_IE7816_GTVE(x)   (((uint8_t)(((uint8_t)(x)) << UART_IE7816_GTVE_SHIFT)) & UART_IE7816_GTVE_MASK)
 
#define UART_IE7816_INITDE_MASK   (0x10U)
 
#define UART_IE7816_INITDE_SHIFT   (4U)
 
#define UART_IE7816_INITDE(x)   (((uint8_t)(((uint8_t)(x)) << UART_IE7816_INITDE_SHIFT)) & UART_IE7816_INITDE_MASK)
 
#define UART_IE7816_BWTE_MASK   (0x20U)
 
#define UART_IE7816_BWTE_SHIFT   (5U)
 
#define UART_IE7816_BWTE(x)   (((uint8_t)(((uint8_t)(x)) << UART_IE7816_BWTE_SHIFT)) & UART_IE7816_BWTE_MASK)
 
#define UART_IE7816_CWTE_MASK   (0x40U)
 
#define UART_IE7816_CWTE_SHIFT   (6U)
 
#define UART_IE7816_CWTE(x)   (((uint8_t)(((uint8_t)(x)) << UART_IE7816_CWTE_SHIFT)) & UART_IE7816_CWTE_MASK)
 
#define UART_IE7816_WTE_MASK   (0x80U)
 
#define UART_IE7816_WTE_SHIFT   (7U)
 
#define UART_IE7816_WTE(x)   (((uint8_t)(((uint8_t)(x)) << UART_IE7816_WTE_SHIFT)) & UART_IE7816_WTE_MASK)
 
IS7816 - UART 7816 Interrupt Status Register
#define UART_IS7816_RXT_MASK   (0x1U)
 
#define UART_IS7816_RXT_SHIFT   (0U)
 
#define UART_IS7816_RXT(x)   (((uint8_t)(((uint8_t)(x)) << UART_IS7816_RXT_SHIFT)) & UART_IS7816_RXT_MASK)
 
#define UART_IS7816_TXT_MASK   (0x2U)
 
#define UART_IS7816_TXT_SHIFT   (1U)
 
#define UART_IS7816_TXT(x)   (((uint8_t)(((uint8_t)(x)) << UART_IS7816_TXT_SHIFT)) & UART_IS7816_TXT_MASK)
 
#define UART_IS7816_GTV_MASK   (0x4U)
 
#define UART_IS7816_GTV_SHIFT   (2U)
 
#define UART_IS7816_GTV(x)   (((uint8_t)(((uint8_t)(x)) << UART_IS7816_GTV_SHIFT)) & UART_IS7816_GTV_MASK)
 
#define UART_IS7816_INITD_MASK   (0x10U)
 
#define UART_IS7816_INITD_SHIFT   (4U)
 
#define UART_IS7816_INITD(x)   (((uint8_t)(((uint8_t)(x)) << UART_IS7816_INITD_SHIFT)) & UART_IS7816_INITD_MASK)
 
#define UART_IS7816_BWT_MASK   (0x20U)
 
#define UART_IS7816_BWT_SHIFT   (5U)
 
#define UART_IS7816_BWT(x)   (((uint8_t)(((uint8_t)(x)) << UART_IS7816_BWT_SHIFT)) & UART_IS7816_BWT_MASK)
 
#define UART_IS7816_CWT_MASK   (0x40U)
 
#define UART_IS7816_CWT_SHIFT   (6U)
 
#define UART_IS7816_CWT(x)   (((uint8_t)(((uint8_t)(x)) << UART_IS7816_CWT_SHIFT)) & UART_IS7816_CWT_MASK)
 
#define UART_IS7816_WT_MASK   (0x80U)
 
#define UART_IS7816_WT_SHIFT   (7U)
 
#define UART_IS7816_WT(x)   (((uint8_t)(((uint8_t)(x)) << UART_IS7816_WT_SHIFT)) & UART_IS7816_WT_MASK)
 
WP7816T0 - UART 7816 Wait Parameter Register
#define UART_WP7816T0_WI_MASK   (0xFFU)
 
#define UART_WP7816T0_WI_SHIFT   (0U)
 
#define UART_WP7816T0_WI(x)   (((uint8_t)(((uint8_t)(x)) << UART_WP7816T0_WI_SHIFT)) & UART_WP7816T0_WI_MASK)
 
WP7816T1 - UART 7816 Wait Parameter Register
#define UART_WP7816T1_BWI_MASK   (0xFU)
 
#define UART_WP7816T1_BWI_SHIFT   (0U)
 
#define UART_WP7816T1_BWI(x)   (((uint8_t)(((uint8_t)(x)) << UART_WP7816T1_BWI_SHIFT)) & UART_WP7816T1_BWI_MASK)
 
#define UART_WP7816T1_CWI_MASK   (0xF0U)
 
#define UART_WP7816T1_CWI_SHIFT   (4U)
 
#define UART_WP7816T1_CWI(x)   (((uint8_t)(((uint8_t)(x)) << UART_WP7816T1_CWI_SHIFT)) & UART_WP7816T1_CWI_MASK)
 
WN7816 - UART 7816 Wait N Register
#define UART_WN7816_GTN_MASK   (0xFFU)
 
#define UART_WN7816_GTN_SHIFT   (0U)
 
#define UART_WN7816_GTN(x)   (((uint8_t)(((uint8_t)(x)) << UART_WN7816_GTN_SHIFT)) & UART_WN7816_GTN_MASK)
 
WF7816 - UART 7816 Wait FD Register
#define UART_WF7816_GTFD_MASK   (0xFFU)
 
#define UART_WF7816_GTFD_SHIFT   (0U)
 
#define UART_WF7816_GTFD(x)   (((uint8_t)(((uint8_t)(x)) << UART_WF7816_GTFD_SHIFT)) & UART_WF7816_GTFD_MASK)
 
ET7816 - UART 7816 Error Threshold Register
#define UART_ET7816_RXTHRESHOLD_MASK   (0xFU)
 
#define UART_ET7816_RXTHRESHOLD_SHIFT   (0U)
 
#define UART_ET7816_RXTHRESHOLD(x)   (((uint8_t)(((uint8_t)(x)) << UART_ET7816_RXTHRESHOLD_SHIFT)) & UART_ET7816_RXTHRESHOLD_MASK)
 
#define UART_ET7816_TXTHRESHOLD_MASK   (0xF0U)
 
#define UART_ET7816_TXTHRESHOLD_SHIFT   (4U)
 
#define UART_ET7816_TXTHRESHOLD(x)   (((uint8_t)(((uint8_t)(x)) << UART_ET7816_TXTHRESHOLD_SHIFT)) & UART_ET7816_TXTHRESHOLD_MASK)
 
TL7816 - UART 7816 Transmit Length Register
#define UART_TL7816_TLEN_MASK   (0xFFU)
 
#define UART_TL7816_TLEN_SHIFT   (0U)
 
#define UART_TL7816_TLEN(x)   (((uint8_t)(((uint8_t)(x)) << UART_TL7816_TLEN_SHIFT)) & UART_TL7816_TLEN_MASK)
 
PERID - Peripheral ID register
#define USB_PERID_ID_MASK   (0x3FU)
 
#define USB_PERID_ID_SHIFT   (0U)
 
#define USB_PERID_ID(x)   (((uint8_t)(((uint8_t)(x)) << USB_PERID_ID_SHIFT)) & USB_PERID_ID_MASK)
 
IDCOMP - Peripheral ID Complement register
#define USB_IDCOMP_NID_MASK   (0x3FU)
 
#define USB_IDCOMP_NID_SHIFT   (0U)
 
#define USB_IDCOMP_NID(x)   (((uint8_t)(((uint8_t)(x)) << USB_IDCOMP_NID_SHIFT)) & USB_IDCOMP_NID_MASK)
 
REV - Peripheral Revision register
#define USB_REV_REV_MASK   (0xFFU)
 
#define USB_REV_REV_SHIFT   (0U)
 
#define USB_REV_REV(x)   (((uint8_t)(((uint8_t)(x)) << USB_REV_REV_SHIFT)) & USB_REV_REV_MASK)
 
ADDINFO - Peripheral Additional Info register
#define USB_ADDINFO_IEHOST_MASK   (0x1U)
 
#define USB_ADDINFO_IEHOST_SHIFT   (0U)
 
#define USB_ADDINFO_IEHOST(x)   (((uint8_t)(((uint8_t)(x)) << USB_ADDINFO_IEHOST_SHIFT)) & USB_ADDINFO_IEHOST_MASK)
 
#define USB_ADDINFO_IRQNUM_MASK   (0xF8U)
 
#define USB_ADDINFO_IRQNUM_SHIFT   (3U)
 
#define USB_ADDINFO_IRQNUM(x)   (((uint8_t)(((uint8_t)(x)) << USB_ADDINFO_IRQNUM_SHIFT)) & USB_ADDINFO_IRQNUM_MASK)
 
OTGISTAT - OTG Interrupt Status register
#define USB_OTGISTAT_AVBUSCHG_MASK   (0x1U)
 
#define USB_OTGISTAT_AVBUSCHG_SHIFT   (0U)
 
#define USB_OTGISTAT_AVBUSCHG(x)   (((uint8_t)(((uint8_t)(x)) << USB_OTGISTAT_AVBUSCHG_SHIFT)) & USB_OTGISTAT_AVBUSCHG_MASK)
 
#define USB_OTGISTAT_B_SESS_CHG_MASK   (0x4U)
 
#define USB_OTGISTAT_B_SESS_CHG_SHIFT   (2U)
 
#define USB_OTGISTAT_B_SESS_CHG(x)   (((uint8_t)(((uint8_t)(x)) << USB_OTGISTAT_B_SESS_CHG_SHIFT)) & USB_OTGISTAT_B_SESS_CHG_MASK)
 
#define USB_OTGISTAT_SESSVLDCHG_MASK   (0x8U)
 
#define USB_OTGISTAT_SESSVLDCHG_SHIFT   (3U)
 
#define USB_OTGISTAT_SESSVLDCHG(x)   (((uint8_t)(((uint8_t)(x)) << USB_OTGISTAT_SESSVLDCHG_SHIFT)) & USB_OTGISTAT_SESSVLDCHG_MASK)
 
#define USB_OTGISTAT_LINE_STATE_CHG_MASK   (0x20U)
 
#define USB_OTGISTAT_LINE_STATE_CHG_SHIFT   (5U)
 
#define USB_OTGISTAT_LINE_STATE_CHG(x)   (((uint8_t)(((uint8_t)(x)) << USB_OTGISTAT_LINE_STATE_CHG_SHIFT)) & USB_OTGISTAT_LINE_STATE_CHG_MASK)
 
#define USB_OTGISTAT_ONEMSEC_MASK   (0x40U)
 
#define USB_OTGISTAT_ONEMSEC_SHIFT   (6U)
 
#define USB_OTGISTAT_ONEMSEC(x)   (((uint8_t)(((uint8_t)(x)) << USB_OTGISTAT_ONEMSEC_SHIFT)) & USB_OTGISTAT_ONEMSEC_MASK)
 
#define USB_OTGISTAT_IDCHG_MASK   (0x80U)
 
#define USB_OTGISTAT_IDCHG_SHIFT   (7U)
 
#define USB_OTGISTAT_IDCHG(x)   (((uint8_t)(((uint8_t)(x)) << USB_OTGISTAT_IDCHG_SHIFT)) & USB_OTGISTAT_IDCHG_MASK)
 
OTGICR - OTG Interrupt Control register
#define USB_OTGICR_AVBUSEN_MASK   (0x1U)
 
#define USB_OTGICR_AVBUSEN_SHIFT   (0U)
 
#define USB_OTGICR_AVBUSEN(x)   (((uint8_t)(((uint8_t)(x)) << USB_OTGICR_AVBUSEN_SHIFT)) & USB_OTGICR_AVBUSEN_MASK)
 
#define USB_OTGICR_BSESSEN_MASK   (0x4U)
 
#define USB_OTGICR_BSESSEN_SHIFT   (2U)
 
#define USB_OTGICR_BSESSEN(x)   (((uint8_t)(((uint8_t)(x)) << USB_OTGICR_BSESSEN_SHIFT)) & USB_OTGICR_BSESSEN_MASK)
 
#define USB_OTGICR_SESSVLDEN_MASK   (0x8U)
 
#define USB_OTGICR_SESSVLDEN_SHIFT   (3U)
 
#define USB_OTGICR_SESSVLDEN(x)   (((uint8_t)(((uint8_t)(x)) << USB_OTGICR_SESSVLDEN_SHIFT)) & USB_OTGICR_SESSVLDEN_MASK)
 
#define USB_OTGICR_LINESTATEEN_MASK   (0x20U)
 
#define USB_OTGICR_LINESTATEEN_SHIFT   (5U)
 
#define USB_OTGICR_LINESTATEEN(x)   (((uint8_t)(((uint8_t)(x)) << USB_OTGICR_LINESTATEEN_SHIFT)) & USB_OTGICR_LINESTATEEN_MASK)
 
#define USB_OTGICR_ONEMSECEN_MASK   (0x40U)
 
#define USB_OTGICR_ONEMSECEN_SHIFT   (6U)
 
#define USB_OTGICR_ONEMSECEN(x)   (((uint8_t)(((uint8_t)(x)) << USB_OTGICR_ONEMSECEN_SHIFT)) & USB_OTGICR_ONEMSECEN_MASK)
 
#define USB_OTGICR_IDEN_MASK   (0x80U)
 
#define USB_OTGICR_IDEN_SHIFT   (7U)
 
#define USB_OTGICR_IDEN(x)   (((uint8_t)(((uint8_t)(x)) << USB_OTGICR_IDEN_SHIFT)) & USB_OTGICR_IDEN_MASK)
 
OTGSTAT - OTG Status register
#define USB_OTGSTAT_AVBUSVLD_MASK   (0x1U)
 
#define USB_OTGSTAT_AVBUSVLD_SHIFT   (0U)
 
#define USB_OTGSTAT_AVBUSVLD(x)   (((uint8_t)(((uint8_t)(x)) << USB_OTGSTAT_AVBUSVLD_SHIFT)) & USB_OTGSTAT_AVBUSVLD_MASK)
 
#define USB_OTGSTAT_BSESSEND_MASK   (0x4U)
 
#define USB_OTGSTAT_BSESSEND_SHIFT   (2U)
 
#define USB_OTGSTAT_BSESSEND(x)   (((uint8_t)(((uint8_t)(x)) << USB_OTGSTAT_BSESSEND_SHIFT)) & USB_OTGSTAT_BSESSEND_MASK)
 
#define USB_OTGSTAT_SESS_VLD_MASK   (0x8U)
 
#define USB_OTGSTAT_SESS_VLD_SHIFT   (3U)
 
#define USB_OTGSTAT_SESS_VLD(x)   (((uint8_t)(((uint8_t)(x)) << USB_OTGSTAT_SESS_VLD_SHIFT)) & USB_OTGSTAT_SESS_VLD_MASK)
 
#define USB_OTGSTAT_LINESTATESTABLE_MASK   (0x20U)
 
#define USB_OTGSTAT_LINESTATESTABLE_SHIFT   (5U)
 
#define USB_OTGSTAT_LINESTATESTABLE(x)   (((uint8_t)(((uint8_t)(x)) << USB_OTGSTAT_LINESTATESTABLE_SHIFT)) & USB_OTGSTAT_LINESTATESTABLE_MASK)
 
#define USB_OTGSTAT_ONEMSECEN_MASK   (0x40U)
 
#define USB_OTGSTAT_ONEMSECEN_SHIFT   (6U)
 
#define USB_OTGSTAT_ONEMSECEN(x)   (((uint8_t)(((uint8_t)(x)) << USB_OTGSTAT_ONEMSECEN_SHIFT)) & USB_OTGSTAT_ONEMSECEN_MASK)
 
#define USB_OTGSTAT_ID_MASK   (0x80U)
 
#define USB_OTGSTAT_ID_SHIFT   (7U)
 
#define USB_OTGSTAT_ID(x)   (((uint8_t)(((uint8_t)(x)) << USB_OTGSTAT_ID_SHIFT)) & USB_OTGSTAT_ID_MASK)
 
OTGCTL - OTG Control register
#define USB_OTGCTL_OTGEN_MASK   (0x4U)
 
#define USB_OTGCTL_OTGEN_SHIFT   (2U)
 
#define USB_OTGCTL_OTGEN(x)   (((uint8_t)(((uint8_t)(x)) << USB_OTGCTL_OTGEN_SHIFT)) & USB_OTGCTL_OTGEN_MASK)
 
#define USB_OTGCTL_DMLOW_MASK   (0x10U)
 
#define USB_OTGCTL_DMLOW_SHIFT   (4U)
 
#define USB_OTGCTL_DMLOW(x)   (((uint8_t)(((uint8_t)(x)) << USB_OTGCTL_DMLOW_SHIFT)) & USB_OTGCTL_DMLOW_MASK)
 
#define USB_OTGCTL_DPLOW_MASK   (0x20U)
 
#define USB_OTGCTL_DPLOW_SHIFT   (5U)
 
#define USB_OTGCTL_DPLOW(x)   (((uint8_t)(((uint8_t)(x)) << USB_OTGCTL_DPLOW_SHIFT)) & USB_OTGCTL_DPLOW_MASK)
 
#define USB_OTGCTL_DPHIGH_MASK   (0x80U)
 
#define USB_OTGCTL_DPHIGH_SHIFT   (7U)
 
#define USB_OTGCTL_DPHIGH(x)   (((uint8_t)(((uint8_t)(x)) << USB_OTGCTL_DPHIGH_SHIFT)) & USB_OTGCTL_DPHIGH_MASK)
 
ISTAT - Interrupt Status register
#define USB_ISTAT_USBRST_MASK   (0x1U)
 
#define USB_ISTAT_USBRST_SHIFT   (0U)
 
#define USB_ISTAT_USBRST(x)   (((uint8_t)(((uint8_t)(x)) << USB_ISTAT_USBRST_SHIFT)) & USB_ISTAT_USBRST_MASK)
 
#define USB_ISTAT_ERROR_MASK   (0x2U)
 
#define USB_ISTAT_ERROR_SHIFT   (1U)
 
#define USB_ISTAT_ERROR(x)   (((uint8_t)(((uint8_t)(x)) << USB_ISTAT_ERROR_SHIFT)) & USB_ISTAT_ERROR_MASK)
 
#define USB_ISTAT_SOFTOK_MASK   (0x4U)
 
#define USB_ISTAT_SOFTOK_SHIFT   (2U)
 
#define USB_ISTAT_SOFTOK(x)   (((uint8_t)(((uint8_t)(x)) << USB_ISTAT_SOFTOK_SHIFT)) & USB_ISTAT_SOFTOK_MASK)
 
#define USB_ISTAT_TOKDNE_MASK   (0x8U)
 
#define USB_ISTAT_TOKDNE_SHIFT   (3U)
 
#define USB_ISTAT_TOKDNE(x)   (((uint8_t)(((uint8_t)(x)) << USB_ISTAT_TOKDNE_SHIFT)) & USB_ISTAT_TOKDNE_MASK)
 
#define USB_ISTAT_SLEEP_MASK   (0x10U)
 
#define USB_ISTAT_SLEEP_SHIFT   (4U)
 
#define USB_ISTAT_SLEEP(x)   (((uint8_t)(((uint8_t)(x)) << USB_ISTAT_SLEEP_SHIFT)) & USB_ISTAT_SLEEP_MASK)
 
#define USB_ISTAT_RESUME_MASK   (0x20U)
 
#define USB_ISTAT_RESUME_SHIFT   (5U)
 
#define USB_ISTAT_RESUME(x)   (((uint8_t)(((uint8_t)(x)) << USB_ISTAT_RESUME_SHIFT)) & USB_ISTAT_RESUME_MASK)
 
#define USB_ISTAT_ATTACH_MASK   (0x40U)
 
#define USB_ISTAT_ATTACH_SHIFT   (6U)
 
#define USB_ISTAT_ATTACH(x)   (((uint8_t)(((uint8_t)(x)) << USB_ISTAT_ATTACH_SHIFT)) & USB_ISTAT_ATTACH_MASK)
 
#define USB_ISTAT_STALL_MASK   (0x80U)
 
#define USB_ISTAT_STALL_SHIFT   (7U)
 
#define USB_ISTAT_STALL(x)   (((uint8_t)(((uint8_t)(x)) << USB_ISTAT_STALL_SHIFT)) & USB_ISTAT_STALL_MASK)
 
INTEN - Interrupt Enable register
#define USB_INTEN_USBRSTEN_MASK   (0x1U)
 
#define USB_INTEN_USBRSTEN_SHIFT   (0U)
 
#define USB_INTEN_USBRSTEN(x)   (((uint8_t)(((uint8_t)(x)) << USB_INTEN_USBRSTEN_SHIFT)) & USB_INTEN_USBRSTEN_MASK)
 
#define USB_INTEN_ERROREN_MASK   (0x2U)
 
#define USB_INTEN_ERROREN_SHIFT   (1U)
 
#define USB_INTEN_ERROREN(x)   (((uint8_t)(((uint8_t)(x)) << USB_INTEN_ERROREN_SHIFT)) & USB_INTEN_ERROREN_MASK)
 
#define USB_INTEN_SOFTOKEN_MASK   (0x4U)
 
#define USB_INTEN_SOFTOKEN_SHIFT   (2U)
 
#define USB_INTEN_SOFTOKEN(x)   (((uint8_t)(((uint8_t)(x)) << USB_INTEN_SOFTOKEN_SHIFT)) & USB_INTEN_SOFTOKEN_MASK)
 
#define USB_INTEN_TOKDNEEN_MASK   (0x8U)
 
#define USB_INTEN_TOKDNEEN_SHIFT   (3U)
 
#define USB_INTEN_TOKDNEEN(x)   (((uint8_t)(((uint8_t)(x)) << USB_INTEN_TOKDNEEN_SHIFT)) & USB_INTEN_TOKDNEEN_MASK)
 
#define USB_INTEN_SLEEPEN_MASK   (0x10U)
 
#define USB_INTEN_SLEEPEN_SHIFT   (4U)
 
#define USB_INTEN_SLEEPEN(x)   (((uint8_t)(((uint8_t)(x)) << USB_INTEN_SLEEPEN_SHIFT)) & USB_INTEN_SLEEPEN_MASK)
 
#define USB_INTEN_RESUMEEN_MASK   (0x20U)
 
#define USB_INTEN_RESUMEEN_SHIFT   (5U)
 
#define USB_INTEN_RESUMEEN(x)   (((uint8_t)(((uint8_t)(x)) << USB_INTEN_RESUMEEN_SHIFT)) & USB_INTEN_RESUMEEN_MASK)
 
#define USB_INTEN_ATTACHEN_MASK   (0x40U)
 
#define USB_INTEN_ATTACHEN_SHIFT   (6U)
 
#define USB_INTEN_ATTACHEN(x)   (((uint8_t)(((uint8_t)(x)) << USB_INTEN_ATTACHEN_SHIFT)) & USB_INTEN_ATTACHEN_MASK)
 
#define USB_INTEN_STALLEN_MASK   (0x80U)
 
#define USB_INTEN_STALLEN_SHIFT   (7U)
 
#define USB_INTEN_STALLEN(x)   (((uint8_t)(((uint8_t)(x)) << USB_INTEN_STALLEN_SHIFT)) & USB_INTEN_STALLEN_MASK)
 
ERRSTAT - Error Interrupt Status register
#define USB_ERRSTAT_PIDERR_MASK   (0x1U)
 
#define USB_ERRSTAT_PIDERR_SHIFT   (0U)
 
#define USB_ERRSTAT_PIDERR(x)   (((uint8_t)(((uint8_t)(x)) << USB_ERRSTAT_PIDERR_SHIFT)) & USB_ERRSTAT_PIDERR_MASK)
 
#define USB_ERRSTAT_CRC5EOF_MASK   (0x2U)
 
#define USB_ERRSTAT_CRC5EOF_SHIFT   (1U)
 
#define USB_ERRSTAT_CRC5EOF(x)   (((uint8_t)(((uint8_t)(x)) << USB_ERRSTAT_CRC5EOF_SHIFT)) & USB_ERRSTAT_CRC5EOF_MASK)
 
#define USB_ERRSTAT_CRC16_MASK   (0x4U)
 
#define USB_ERRSTAT_CRC16_SHIFT   (2U)
 
#define USB_ERRSTAT_CRC16(x)   (((uint8_t)(((uint8_t)(x)) << USB_ERRSTAT_CRC16_SHIFT)) & USB_ERRSTAT_CRC16_MASK)
 
#define USB_ERRSTAT_DFN8_MASK   (0x8U)
 
#define USB_ERRSTAT_DFN8_SHIFT   (3U)
 
#define USB_ERRSTAT_DFN8(x)   (((uint8_t)(((uint8_t)(x)) << USB_ERRSTAT_DFN8_SHIFT)) & USB_ERRSTAT_DFN8_MASK)
 
#define USB_ERRSTAT_BTOERR_MASK   (0x10U)
 
#define USB_ERRSTAT_BTOERR_SHIFT   (4U)
 
#define USB_ERRSTAT_BTOERR(x)   (((uint8_t)(((uint8_t)(x)) << USB_ERRSTAT_BTOERR_SHIFT)) & USB_ERRSTAT_BTOERR_MASK)
 
#define USB_ERRSTAT_DMAERR_MASK   (0x20U)
 
#define USB_ERRSTAT_DMAERR_SHIFT   (5U)
 
#define USB_ERRSTAT_DMAERR(x)   (((uint8_t)(((uint8_t)(x)) << USB_ERRSTAT_DMAERR_SHIFT)) & USB_ERRSTAT_DMAERR_MASK)
 
#define USB_ERRSTAT_BTSERR_MASK   (0x80U)
 
#define USB_ERRSTAT_BTSERR_SHIFT   (7U)
 
#define USB_ERRSTAT_BTSERR(x)   (((uint8_t)(((uint8_t)(x)) << USB_ERRSTAT_BTSERR_SHIFT)) & USB_ERRSTAT_BTSERR_MASK)
 
ERREN - Error Interrupt Enable register
#define USB_ERREN_PIDERREN_MASK   (0x1U)
 
#define USB_ERREN_PIDERREN_SHIFT   (0U)
 
#define USB_ERREN_PIDERREN(x)   (((uint8_t)(((uint8_t)(x)) << USB_ERREN_PIDERREN_SHIFT)) & USB_ERREN_PIDERREN_MASK)
 
#define USB_ERREN_CRC5EOFEN_MASK   (0x2U)
 
#define USB_ERREN_CRC5EOFEN_SHIFT   (1U)
 
#define USB_ERREN_CRC5EOFEN(x)   (((uint8_t)(((uint8_t)(x)) << USB_ERREN_CRC5EOFEN_SHIFT)) & USB_ERREN_CRC5EOFEN_MASK)
 
#define USB_ERREN_CRC16EN_MASK   (0x4U)
 
#define USB_ERREN_CRC16EN_SHIFT   (2U)
 
#define USB_ERREN_CRC16EN(x)   (((uint8_t)(((uint8_t)(x)) << USB_ERREN_CRC16EN_SHIFT)) & USB_ERREN_CRC16EN_MASK)
 
#define USB_ERREN_DFN8EN_MASK   (0x8U)
 
#define USB_ERREN_DFN8EN_SHIFT   (3U)
 
#define USB_ERREN_DFN8EN(x)   (((uint8_t)(((uint8_t)(x)) << USB_ERREN_DFN8EN_SHIFT)) & USB_ERREN_DFN8EN_MASK)
 
#define USB_ERREN_BTOERREN_MASK   (0x10U)
 
#define USB_ERREN_BTOERREN_SHIFT   (4U)
 
#define USB_ERREN_BTOERREN(x)   (((uint8_t)(((uint8_t)(x)) << USB_ERREN_BTOERREN_SHIFT)) & USB_ERREN_BTOERREN_MASK)
 
#define USB_ERREN_DMAERREN_MASK   (0x20U)
 
#define USB_ERREN_DMAERREN_SHIFT   (5U)
 
#define USB_ERREN_DMAERREN(x)   (((uint8_t)(((uint8_t)(x)) << USB_ERREN_DMAERREN_SHIFT)) & USB_ERREN_DMAERREN_MASK)
 
#define USB_ERREN_BTSERREN_MASK   (0x80U)
 
#define USB_ERREN_BTSERREN_SHIFT   (7U)
 
#define USB_ERREN_BTSERREN(x)   (((uint8_t)(((uint8_t)(x)) << USB_ERREN_BTSERREN_SHIFT)) & USB_ERREN_BTSERREN_MASK)
 
STAT - Status register
#define USB_STAT_ODD_MASK   (0x4U)
 
#define USB_STAT_ODD_SHIFT   (2U)
 
#define USB_STAT_ODD(x)   (((uint8_t)(((uint8_t)(x)) << USB_STAT_ODD_SHIFT)) & USB_STAT_ODD_MASK)
 
#define USB_STAT_TX_MASK   (0x8U)
 
#define USB_STAT_TX_SHIFT   (3U)
 
#define USB_STAT_TX(x)   (((uint8_t)(((uint8_t)(x)) << USB_STAT_TX_SHIFT)) & USB_STAT_TX_MASK)
 
#define USB_STAT_ENDP_MASK   (0xF0U)
 
#define USB_STAT_ENDP_SHIFT   (4U)
 
#define USB_STAT_ENDP(x)   (((uint8_t)(((uint8_t)(x)) << USB_STAT_ENDP_SHIFT)) & USB_STAT_ENDP_MASK)
 
CTL - Control register
#define USB_CTL_USBENSOFEN_MASK   (0x1U)
 
#define USB_CTL_USBENSOFEN_SHIFT   (0U)
 
#define USB_CTL_USBENSOFEN(x)   (((uint8_t)(((uint8_t)(x)) << USB_CTL_USBENSOFEN_SHIFT)) & USB_CTL_USBENSOFEN_MASK)
 
#define USB_CTL_ODDRST_MASK   (0x2U)
 
#define USB_CTL_ODDRST_SHIFT   (1U)
 
#define USB_CTL_ODDRST(x)   (((uint8_t)(((uint8_t)(x)) << USB_CTL_ODDRST_SHIFT)) & USB_CTL_ODDRST_MASK)
 
#define USB_CTL_RESUME_MASK   (0x4U)
 
#define USB_CTL_RESUME_SHIFT   (2U)
 
#define USB_CTL_RESUME(x)   (((uint8_t)(((uint8_t)(x)) << USB_CTL_RESUME_SHIFT)) & USB_CTL_RESUME_MASK)
 
#define USB_CTL_HOSTMODEEN_MASK   (0x8U)
 
#define USB_CTL_HOSTMODEEN_SHIFT   (3U)
 
#define USB_CTL_HOSTMODEEN(x)   (((uint8_t)(((uint8_t)(x)) << USB_CTL_HOSTMODEEN_SHIFT)) & USB_CTL_HOSTMODEEN_MASK)
 
#define USB_CTL_RESET_MASK   (0x10U)
 
#define USB_CTL_RESET_SHIFT   (4U)
 
#define USB_CTL_RESET(x)   (((uint8_t)(((uint8_t)(x)) << USB_CTL_RESET_SHIFT)) & USB_CTL_RESET_MASK)
 
#define USB_CTL_TXSUSPENDTOKENBUSY_MASK   (0x20U)
 
#define USB_CTL_TXSUSPENDTOKENBUSY_SHIFT   (5U)
 
#define USB_CTL_TXSUSPENDTOKENBUSY(x)   (((uint8_t)(((uint8_t)(x)) << USB_CTL_TXSUSPENDTOKENBUSY_SHIFT)) & USB_CTL_TXSUSPENDTOKENBUSY_MASK)
 
#define USB_CTL_SE0_MASK   (0x40U)
 
#define USB_CTL_SE0_SHIFT   (6U)
 
#define USB_CTL_SE0(x)   (((uint8_t)(((uint8_t)(x)) << USB_CTL_SE0_SHIFT)) & USB_CTL_SE0_MASK)
 
#define USB_CTL_JSTATE_MASK   (0x80U)
 
#define USB_CTL_JSTATE_SHIFT   (7U)
 
#define USB_CTL_JSTATE(x)   (((uint8_t)(((uint8_t)(x)) << USB_CTL_JSTATE_SHIFT)) & USB_CTL_JSTATE_MASK)
 
ADDR - Address register
#define USB_ADDR_ADDR_MASK   (0x7FU)
 
#define USB_ADDR_ADDR_SHIFT   (0U)
 
#define USB_ADDR_ADDR(x)   (((uint8_t)(((uint8_t)(x)) << USB_ADDR_ADDR_SHIFT)) & USB_ADDR_ADDR_MASK)
 
#define USB_ADDR_LSEN_MASK   (0x80U)
 
#define USB_ADDR_LSEN_SHIFT   (7U)
 
#define USB_ADDR_LSEN(x)   (((uint8_t)(((uint8_t)(x)) << USB_ADDR_LSEN_SHIFT)) & USB_ADDR_LSEN_MASK)
 
BDTPAGE1 - BDT Page register 1
#define USB_BDTPAGE1_BDTBA_MASK   (0xFEU)
 
#define USB_BDTPAGE1_BDTBA_SHIFT   (1U)
 
#define USB_BDTPAGE1_BDTBA(x)   (((uint8_t)(((uint8_t)(x)) << USB_BDTPAGE1_BDTBA_SHIFT)) & USB_BDTPAGE1_BDTBA_MASK)
 
FRMNUML - Frame Number register Low
#define USB_FRMNUML_FRM_MASK   (0xFFU)
 
#define USB_FRMNUML_FRM_SHIFT   (0U)
 
#define USB_FRMNUML_FRM(x)   (((uint8_t)(((uint8_t)(x)) << USB_FRMNUML_FRM_SHIFT)) & USB_FRMNUML_FRM_MASK)
 
FRMNUMH - Frame Number register High
#define USB_FRMNUMH_FRM_MASK   (0x7U)
 
#define USB_FRMNUMH_FRM_SHIFT   (0U)
 
#define USB_FRMNUMH_FRM(x)   (((uint8_t)(((uint8_t)(x)) << USB_FRMNUMH_FRM_SHIFT)) & USB_FRMNUMH_FRM_MASK)
 
TOKEN - Token register
#define USB_TOKEN_TOKENENDPT_MASK   (0xFU)
 
#define USB_TOKEN_TOKENENDPT_SHIFT   (0U)
 
#define USB_TOKEN_TOKENENDPT(x)   (((uint8_t)(((uint8_t)(x)) << USB_TOKEN_TOKENENDPT_SHIFT)) & USB_TOKEN_TOKENENDPT_MASK)
 
#define USB_TOKEN_TOKENPID_MASK   (0xF0U)
 
#define USB_TOKEN_TOKENPID_SHIFT   (4U)
 
#define USB_TOKEN_TOKENPID(x)   (((uint8_t)(((uint8_t)(x)) << USB_TOKEN_TOKENPID_SHIFT)) & USB_TOKEN_TOKENPID_MASK)
 
SOFTHLD - SOF Threshold register
#define USB_SOFTHLD_CNT_MASK   (0xFFU)
 
#define USB_SOFTHLD_CNT_SHIFT   (0U)
 
#define USB_SOFTHLD_CNT(x)   (((uint8_t)(((uint8_t)(x)) << USB_SOFTHLD_CNT_SHIFT)) & USB_SOFTHLD_CNT_MASK)
 
BDTPAGE2 - BDT Page Register 2
#define USB_BDTPAGE2_BDTBA_MASK   (0xFFU)
 
#define USB_BDTPAGE2_BDTBA_SHIFT   (0U)
 
#define USB_BDTPAGE2_BDTBA(x)   (((uint8_t)(((uint8_t)(x)) << USB_BDTPAGE2_BDTBA_SHIFT)) & USB_BDTPAGE2_BDTBA_MASK)
 
BDTPAGE3 - BDT Page Register 3
#define USB_BDTPAGE3_BDTBA_MASK   (0xFFU)
 
#define USB_BDTPAGE3_BDTBA_SHIFT   (0U)
 
#define USB_BDTPAGE3_BDTBA(x)   (((uint8_t)(((uint8_t)(x)) << USB_BDTPAGE3_BDTBA_SHIFT)) & USB_BDTPAGE3_BDTBA_MASK)
 
ENDPT - Endpoint Control register
#define USB_ENDPT_EPHSHK_MASK   (0x1U)
 
#define USB_ENDPT_EPHSHK_SHIFT   (0U)
 
#define USB_ENDPT_EPHSHK(x)   (((uint8_t)(((uint8_t)(x)) << USB_ENDPT_EPHSHK_SHIFT)) & USB_ENDPT_EPHSHK_MASK)
 
#define USB_ENDPT_EPSTALL_MASK   (0x2U)
 
#define USB_ENDPT_EPSTALL_SHIFT   (1U)
 
#define USB_ENDPT_EPSTALL(x)   (((uint8_t)(((uint8_t)(x)) << USB_ENDPT_EPSTALL_SHIFT)) & USB_ENDPT_EPSTALL_MASK)
 
#define USB_ENDPT_EPTXEN_MASK   (0x4U)
 
#define USB_ENDPT_EPTXEN_SHIFT   (2U)
 
#define USB_ENDPT_EPTXEN(x)   (((uint8_t)(((uint8_t)(x)) << USB_ENDPT_EPTXEN_SHIFT)) & USB_ENDPT_EPTXEN_MASK)
 
#define USB_ENDPT_EPRXEN_MASK   (0x8U)
 
#define USB_ENDPT_EPRXEN_SHIFT   (3U)
 
#define USB_ENDPT_EPRXEN(x)   (((uint8_t)(((uint8_t)(x)) << USB_ENDPT_EPRXEN_SHIFT)) & USB_ENDPT_EPRXEN_MASK)
 
#define USB_ENDPT_EPCTLDIS_MASK   (0x10U)
 
#define USB_ENDPT_EPCTLDIS_SHIFT   (4U)
 
#define USB_ENDPT_EPCTLDIS(x)   (((uint8_t)(((uint8_t)(x)) << USB_ENDPT_EPCTLDIS_SHIFT)) & USB_ENDPT_EPCTLDIS_MASK)
 
#define USB_ENDPT_RETRYDIS_MASK   (0x40U)
 
#define USB_ENDPT_RETRYDIS_SHIFT   (6U)
 
#define USB_ENDPT_RETRYDIS(x)   (((uint8_t)(((uint8_t)(x)) << USB_ENDPT_RETRYDIS_SHIFT)) & USB_ENDPT_RETRYDIS_MASK)
 
#define USB_ENDPT_HOSTWOHUB_MASK   (0x80U)
 
#define USB_ENDPT_HOSTWOHUB_SHIFT   (7U)
 
#define USB_ENDPT_HOSTWOHUB(x)   (((uint8_t)(((uint8_t)(x)) << USB_ENDPT_HOSTWOHUB_SHIFT)) & USB_ENDPT_HOSTWOHUB_MASK)
 
#define USB_ENDPT_COUNT   (16U)
 
USBCTRL - USB Control register
#define USB_USBCTRL_PDE_MASK   (0x40U)
 
#define USB_USBCTRL_PDE_SHIFT   (6U)
 
#define USB_USBCTRL_PDE(x)   (((uint8_t)(((uint8_t)(x)) << USB_USBCTRL_PDE_SHIFT)) & USB_USBCTRL_PDE_MASK)
 
#define USB_USBCTRL_SUSP_MASK   (0x80U)
 
#define USB_USBCTRL_SUSP_SHIFT   (7U)
 
#define USB_USBCTRL_SUSP(x)   (((uint8_t)(((uint8_t)(x)) << USB_USBCTRL_SUSP_SHIFT)) & USB_USBCTRL_SUSP_MASK)
 
OBSERVE - USB OTG Observe register
#define USB_OBSERVE_DMPD_MASK   (0x10U)
 
#define USB_OBSERVE_DMPD_SHIFT   (4U)
 
#define USB_OBSERVE_DMPD(x)   (((uint8_t)(((uint8_t)(x)) << USB_OBSERVE_DMPD_SHIFT)) & USB_OBSERVE_DMPD_MASK)
 
#define USB_OBSERVE_DPPD_MASK   (0x40U)
 
#define USB_OBSERVE_DPPD_SHIFT   (6U)
 
#define USB_OBSERVE_DPPD(x)   (((uint8_t)(((uint8_t)(x)) << USB_OBSERVE_DPPD_SHIFT)) & USB_OBSERVE_DPPD_MASK)
 
#define USB_OBSERVE_DPPU_MASK   (0x80U)
 
#define USB_OBSERVE_DPPU_SHIFT   (7U)
 
#define USB_OBSERVE_DPPU(x)   (((uint8_t)(((uint8_t)(x)) << USB_OBSERVE_DPPU_SHIFT)) & USB_OBSERVE_DPPU_MASK)
 
CONTROL - USB OTG Control register
#define USB_CONTROL_DPPULLUPNONOTG_MASK   (0x10U)
 
#define USB_CONTROL_DPPULLUPNONOTG_SHIFT   (4U)
 
#define USB_CONTROL_DPPULLUPNONOTG(x)   (((uint8_t)(((uint8_t)(x)) << USB_CONTROL_DPPULLUPNONOTG_SHIFT)) & USB_CONTROL_DPPULLUPNONOTG_MASK)
 
USBTRC0 - USB Transceiver Control register 0
#define USB_USBTRC0_USB_RESUME_INT_MASK   (0x1U)
 
#define USB_USBTRC0_USB_RESUME_INT_SHIFT   (0U)
 
#define USB_USBTRC0_USB_RESUME_INT(x)   (((uint8_t)(((uint8_t)(x)) << USB_USBTRC0_USB_RESUME_INT_SHIFT)) & USB_USBTRC0_USB_RESUME_INT_MASK)
 
#define USB_USBTRC0_SYNC_DET_MASK   (0x2U)
 
#define USB_USBTRC0_SYNC_DET_SHIFT   (1U)
 
#define USB_USBTRC0_SYNC_DET(x)   (((uint8_t)(((uint8_t)(x)) << USB_USBTRC0_SYNC_DET_SHIFT)) & USB_USBTRC0_SYNC_DET_MASK)
 
#define USB_USBTRC0_USB_CLK_RECOVERY_INT_MASK   (0x4U)
 
#define USB_USBTRC0_USB_CLK_RECOVERY_INT_SHIFT   (2U)
 
#define USB_USBTRC0_USB_CLK_RECOVERY_INT(x)   (((uint8_t)(((uint8_t)(x)) << USB_USBTRC0_USB_CLK_RECOVERY_INT_SHIFT)) & USB_USBTRC0_USB_CLK_RECOVERY_INT_MASK)
 
#define USB_USBTRC0_USBRESMEN_MASK   (0x20U)
 
#define USB_USBTRC0_USBRESMEN_SHIFT   (5U)
 
#define USB_USBTRC0_USBRESMEN(x)   (((uint8_t)(((uint8_t)(x)) << USB_USBTRC0_USBRESMEN_SHIFT)) & USB_USBTRC0_USBRESMEN_MASK)
 
#define USB_USBTRC0_USBRESET_MASK   (0x80U)
 
#define USB_USBTRC0_USBRESET_SHIFT   (7U)
 
#define USB_USBTRC0_USBRESET(x)   (((uint8_t)(((uint8_t)(x)) << USB_USBTRC0_USBRESET_SHIFT)) & USB_USBTRC0_USBRESET_MASK)
 
USBFRMADJUST - Frame Adjust Register
#define USB_USBFRMADJUST_ADJ_MASK   (0xFFU)
 
#define USB_USBFRMADJUST_ADJ_SHIFT   (0U)
 
#define USB_USBFRMADJUST_ADJ(x)   (((uint8_t)(((uint8_t)(x)) << USB_USBFRMADJUST_ADJ_SHIFT)) & USB_USBFRMADJUST_ADJ_MASK)
 
CLK_RECOVER_CTRL - USB Clock recovery control
#define USB_CLK_RECOVER_CTRL_RESTART_IFRTRIM_EN_MASK   (0x20U)
 
#define USB_CLK_RECOVER_CTRL_RESTART_IFRTRIM_EN_SHIFT   (5U)
 
#define USB_CLK_RECOVER_CTRL_RESTART_IFRTRIM_EN(x)   (((uint8_t)(((uint8_t)(x)) << USB_CLK_RECOVER_CTRL_RESTART_IFRTRIM_EN_SHIFT)) & USB_CLK_RECOVER_CTRL_RESTART_IFRTRIM_EN_MASK)
 
#define USB_CLK_RECOVER_CTRL_RESET_RESUME_ROUGH_EN_MASK   (0x40U)
 
#define USB_CLK_RECOVER_CTRL_RESET_RESUME_ROUGH_EN_SHIFT   (6U)
 
#define USB_CLK_RECOVER_CTRL_RESET_RESUME_ROUGH_EN(x)   (((uint8_t)(((uint8_t)(x)) << USB_CLK_RECOVER_CTRL_RESET_RESUME_ROUGH_EN_SHIFT)) & USB_CLK_RECOVER_CTRL_RESET_RESUME_ROUGH_EN_MASK)
 
#define USB_CLK_RECOVER_CTRL_CLOCK_RECOVER_EN_MASK   (0x80U)
 
#define USB_CLK_RECOVER_CTRL_CLOCK_RECOVER_EN_SHIFT   (7U)
 
#define USB_CLK_RECOVER_CTRL_CLOCK_RECOVER_EN(x)   (((uint8_t)(((uint8_t)(x)) << USB_CLK_RECOVER_CTRL_CLOCK_RECOVER_EN_SHIFT)) & USB_CLK_RECOVER_CTRL_CLOCK_RECOVER_EN_MASK)
 
CLK_RECOVER_IRC_EN - IRC48M oscillator enable register
#define USB_CLK_RECOVER_IRC_EN_REG_EN_MASK   (0x1U)
 
#define USB_CLK_RECOVER_IRC_EN_REG_EN_SHIFT   (0U)
 
#define USB_CLK_RECOVER_IRC_EN_REG_EN(x)   (((uint8_t)(((uint8_t)(x)) << USB_CLK_RECOVER_IRC_EN_REG_EN_SHIFT)) & USB_CLK_RECOVER_IRC_EN_REG_EN_MASK)
 
#define USB_CLK_RECOVER_IRC_EN_IRC_EN_MASK   (0x2U)
 
#define USB_CLK_RECOVER_IRC_EN_IRC_EN_SHIFT   (1U)
 
#define USB_CLK_RECOVER_IRC_EN_IRC_EN(x)   (((uint8_t)(((uint8_t)(x)) << USB_CLK_RECOVER_IRC_EN_IRC_EN_SHIFT)) & USB_CLK_RECOVER_IRC_EN_IRC_EN_MASK)
 
CLK_RECOVER_INT_STATUS - Clock recovery separated interrupt status
#define USB_CLK_RECOVER_INT_STATUS_OVF_ERROR_MASK   (0x10U)
 
#define USB_CLK_RECOVER_INT_STATUS_OVF_ERROR_SHIFT   (4U)
 
#define USB_CLK_RECOVER_INT_STATUS_OVF_ERROR(x)   (((uint8_t)(((uint8_t)(x)) << USB_CLK_RECOVER_INT_STATUS_OVF_ERROR_SHIFT)) & USB_CLK_RECOVER_INT_STATUS_OVF_ERROR_MASK)
 
CONTROL - Control register
#define USBDCD_CONTROL_IACK_MASK   (0x1U)
 
#define USBDCD_CONTROL_IACK_SHIFT   (0U)
 
#define USBDCD_CONTROL_IACK(x)   (((uint32_t)(((uint32_t)(x)) << USBDCD_CONTROL_IACK_SHIFT)) & USBDCD_CONTROL_IACK_MASK)
 
#define USBDCD_CONTROL_IF_MASK   (0x100U)
 
#define USBDCD_CONTROL_IF_SHIFT   (8U)
 
#define USBDCD_CONTROL_IF(x)   (((uint32_t)(((uint32_t)(x)) << USBDCD_CONTROL_IF_SHIFT)) & USBDCD_CONTROL_IF_MASK)
 
#define USBDCD_CONTROL_IE_MASK   (0x10000U)
 
#define USBDCD_CONTROL_IE_SHIFT   (16U)
 
#define USBDCD_CONTROL_IE(x)   (((uint32_t)(((uint32_t)(x)) << USBDCD_CONTROL_IE_SHIFT)) & USBDCD_CONTROL_IE_MASK)
 
#define USBDCD_CONTROL_BC12_MASK   (0x20000U)
 
#define USBDCD_CONTROL_BC12_SHIFT   (17U)
 
#define USBDCD_CONTROL_BC12(x)   (((uint32_t)(((uint32_t)(x)) << USBDCD_CONTROL_BC12_SHIFT)) & USBDCD_CONTROL_BC12_MASK)
 
#define USBDCD_CONTROL_START_MASK   (0x1000000U)
 
#define USBDCD_CONTROL_START_SHIFT   (24U)
 
#define USBDCD_CONTROL_START(x)   (((uint32_t)(((uint32_t)(x)) << USBDCD_CONTROL_START_SHIFT)) & USBDCD_CONTROL_START_MASK)
 
#define USBDCD_CONTROL_SR_MASK   (0x2000000U)
 
#define USBDCD_CONTROL_SR_SHIFT   (25U)
 
#define USBDCD_CONTROL_SR(x)   (((uint32_t)(((uint32_t)(x)) << USBDCD_CONTROL_SR_SHIFT)) & USBDCD_CONTROL_SR_MASK)
 
CLOCK - Clock register
#define USBDCD_CLOCK_CLOCK_UNIT_MASK   (0x1U)
 
#define USBDCD_CLOCK_CLOCK_UNIT_SHIFT   (0U)
 
#define USBDCD_CLOCK_CLOCK_UNIT(x)   (((uint32_t)(((uint32_t)(x)) << USBDCD_CLOCK_CLOCK_UNIT_SHIFT)) & USBDCD_CLOCK_CLOCK_UNIT_MASK)
 
#define USBDCD_CLOCK_CLOCK_SPEED_MASK   (0xFFCU)
 
#define USBDCD_CLOCK_CLOCK_SPEED_SHIFT   (2U)
 
#define USBDCD_CLOCK_CLOCK_SPEED(x)   (((uint32_t)(((uint32_t)(x)) << USBDCD_CLOCK_CLOCK_SPEED_SHIFT)) & USBDCD_CLOCK_CLOCK_SPEED_MASK)
 
STATUS - Status register
#define USBDCD_STATUS_SEQ_RES_MASK   (0x30000U)
 
#define USBDCD_STATUS_SEQ_RES_SHIFT   (16U)
 
#define USBDCD_STATUS_SEQ_RES(x)   (((uint32_t)(((uint32_t)(x)) << USBDCD_STATUS_SEQ_RES_SHIFT)) & USBDCD_STATUS_SEQ_RES_MASK)
 
#define USBDCD_STATUS_SEQ_STAT_MASK   (0xC0000U)
 
#define USBDCD_STATUS_SEQ_STAT_SHIFT   (18U)
 
#define USBDCD_STATUS_SEQ_STAT(x)   (((uint32_t)(((uint32_t)(x)) << USBDCD_STATUS_SEQ_STAT_SHIFT)) & USBDCD_STATUS_SEQ_STAT_MASK)
 
#define USBDCD_STATUS_ERR_MASK   (0x100000U)
 
#define USBDCD_STATUS_ERR_SHIFT   (20U)
 
#define USBDCD_STATUS_ERR(x)   (((uint32_t)(((uint32_t)(x)) << USBDCD_STATUS_ERR_SHIFT)) & USBDCD_STATUS_ERR_MASK)
 
#define USBDCD_STATUS_TO_MASK   (0x200000U)
 
#define USBDCD_STATUS_TO_SHIFT   (21U)
 
#define USBDCD_STATUS_TO(x)   (((uint32_t)(((uint32_t)(x)) << USBDCD_STATUS_TO_SHIFT)) & USBDCD_STATUS_TO_MASK)
 
#define USBDCD_STATUS_ACTIVE_MASK   (0x400000U)
 
#define USBDCD_STATUS_ACTIVE_SHIFT   (22U)
 
#define USBDCD_STATUS_ACTIVE(x)   (((uint32_t)(((uint32_t)(x)) << USBDCD_STATUS_ACTIVE_SHIFT)) & USBDCD_STATUS_ACTIVE_MASK)
 
TIMER0 - TIMER0 register
#define USBDCD_TIMER0_TUNITCON_MASK   (0xFFFU)
 
#define USBDCD_TIMER0_TUNITCON_SHIFT   (0U)
 
#define USBDCD_TIMER0_TUNITCON(x)   (((uint32_t)(((uint32_t)(x)) << USBDCD_TIMER0_TUNITCON_SHIFT)) & USBDCD_TIMER0_TUNITCON_MASK)
 
#define USBDCD_TIMER0_TSEQ_INIT_MASK   (0x3FF0000U)
 
#define USBDCD_TIMER0_TSEQ_INIT_SHIFT   (16U)
 
#define USBDCD_TIMER0_TSEQ_INIT(x)   (((uint32_t)(((uint32_t)(x)) << USBDCD_TIMER0_TSEQ_INIT_SHIFT)) & USBDCD_TIMER0_TSEQ_INIT_MASK)
 
TIMER1 - TIMER1 register
#define USBDCD_TIMER1_TVDPSRC_ON_MASK   (0x3FFU)
 
#define USBDCD_TIMER1_TVDPSRC_ON_SHIFT   (0U)
 
#define USBDCD_TIMER1_TVDPSRC_ON(x)   (((uint32_t)(((uint32_t)(x)) << USBDCD_TIMER1_TVDPSRC_ON_SHIFT)) & USBDCD_TIMER1_TVDPSRC_ON_MASK)
 
#define USBDCD_TIMER1_TDCD_DBNC_MASK   (0x3FF0000U)
 
#define USBDCD_TIMER1_TDCD_DBNC_SHIFT   (16U)
 
#define USBDCD_TIMER1_TDCD_DBNC(x)   (((uint32_t)(((uint32_t)(x)) << USBDCD_TIMER1_TDCD_DBNC_SHIFT)) & USBDCD_TIMER1_TDCD_DBNC_MASK)
 
TIMER2_BC11 - TIMER2_BC11 register
#define USBDCD_TIMER2_BC11_CHECK_DM_MASK   (0xFU)
 
#define USBDCD_TIMER2_BC11_CHECK_DM_SHIFT   (0U)
 
#define USBDCD_TIMER2_BC11_CHECK_DM(x)   (((uint32_t)(((uint32_t)(x)) << USBDCD_TIMER2_BC11_CHECK_DM_SHIFT)) & USBDCD_TIMER2_BC11_CHECK_DM_MASK)
 
#define USBDCD_TIMER2_BC11_TVDPSRC_CON_MASK   (0x3FF0000U)
 
#define USBDCD_TIMER2_BC11_TVDPSRC_CON_SHIFT   (16U)
 
#define USBDCD_TIMER2_BC11_TVDPSRC_CON(x)   (((uint32_t)(((uint32_t)(x)) << USBDCD_TIMER2_BC11_TVDPSRC_CON_SHIFT)) & USBDCD_TIMER2_BC11_TVDPSRC_CON_MASK)
 
TIMER2_BC12 - TIMER2_BC12 register
#define USBDCD_TIMER2_BC12_TVDMSRC_ON_MASK   (0x3FFU)
 
#define USBDCD_TIMER2_BC12_TVDMSRC_ON_SHIFT   (0U)
 
#define USBDCD_TIMER2_BC12_TVDMSRC_ON(x)   (((uint32_t)(((uint32_t)(x)) << USBDCD_TIMER2_BC12_TVDMSRC_ON_SHIFT)) & USBDCD_TIMER2_BC12_TVDMSRC_ON_MASK)
 
#define USBDCD_TIMER2_BC12_TWAIT_AFTER_PRD_MASK   (0x3FF0000U)
 
#define USBDCD_TIMER2_BC12_TWAIT_AFTER_PRD_SHIFT   (16U)
 
#define USBDCD_TIMER2_BC12_TWAIT_AFTER_PRD(x)   (((uint32_t)(((uint32_t)(x)) << USBDCD_TIMER2_BC12_TWAIT_AFTER_PRD_SHIFT)) & USBDCD_TIMER2_BC12_TWAIT_AFTER_PRD_MASK)
 
TRM - VREF Trim Register
#define VREF_TRM_TRIM_MASK   (0x3FU)
 
#define VREF_TRM_TRIM_SHIFT   (0U)
 
#define VREF_TRM_TRIM(x)   (((uint8_t)(((uint8_t)(x)) << VREF_TRM_TRIM_SHIFT)) & VREF_TRM_TRIM_MASK)
 
#define VREF_TRM_CHOPEN_MASK   (0x40U)
 
#define VREF_TRM_CHOPEN_SHIFT   (6U)
 
#define VREF_TRM_CHOPEN(x)   (((uint8_t)(((uint8_t)(x)) << VREF_TRM_CHOPEN_SHIFT)) & VREF_TRM_CHOPEN_MASK)
 
SC - VREF Status and Control Register
#define VREF_SC_MODE_LV_MASK   (0x3U)
 
#define VREF_SC_MODE_LV_SHIFT   (0U)
 
#define VREF_SC_MODE_LV(x)   (((uint8_t)(((uint8_t)(x)) << VREF_SC_MODE_LV_SHIFT)) & VREF_SC_MODE_LV_MASK)
 
#define VREF_SC_VREFST_MASK   (0x4U)
 
#define VREF_SC_VREFST_SHIFT   (2U)
 
#define VREF_SC_VREFST(x)   (((uint8_t)(((uint8_t)(x)) << VREF_SC_VREFST_SHIFT)) & VREF_SC_VREFST_MASK)
 
#define VREF_SC_ICOMPEN_MASK   (0x20U)
 
#define VREF_SC_ICOMPEN_SHIFT   (5U)
 
#define VREF_SC_ICOMPEN(x)   (((uint8_t)(((uint8_t)(x)) << VREF_SC_ICOMPEN_SHIFT)) & VREF_SC_ICOMPEN_MASK)
 
#define VREF_SC_REGEN_MASK   (0x40U)
 
#define VREF_SC_REGEN_SHIFT   (6U)
 
#define VREF_SC_REGEN(x)   (((uint8_t)(((uint8_t)(x)) << VREF_SC_REGEN_SHIFT)) & VREF_SC_REGEN_MASK)
 
#define VREF_SC_VREFEN_MASK   (0x80U)
 
#define VREF_SC_VREFEN_SHIFT   (7U)
 
#define VREF_SC_VREFEN(x)   (((uint8_t)(((uint8_t)(x)) << VREF_SC_VREFEN_SHIFT)) & VREF_SC_VREFEN_MASK)
 
STCTRLH - Watchdog Status and Control Register High
#define WDOG_STCTRLH_WDOGEN_MASK   (0x1U)
 
#define WDOG_STCTRLH_WDOGEN_SHIFT   (0U)
 
#define WDOG_STCTRLH_WDOGEN(x)   (((uint16_t)(((uint16_t)(x)) << WDOG_STCTRLH_WDOGEN_SHIFT)) & WDOG_STCTRLH_WDOGEN_MASK)
 
#define WDOG_STCTRLH_CLKSRC_MASK   (0x2U)
 
#define WDOG_STCTRLH_CLKSRC_SHIFT   (1U)
 
#define WDOG_STCTRLH_CLKSRC(x)   (((uint16_t)(((uint16_t)(x)) << WDOG_STCTRLH_CLKSRC_SHIFT)) & WDOG_STCTRLH_CLKSRC_MASK)
 
#define WDOG_STCTRLH_IRQRSTEN_MASK   (0x4U)
 
#define WDOG_STCTRLH_IRQRSTEN_SHIFT   (2U)
 
#define WDOG_STCTRLH_IRQRSTEN(x)   (((uint16_t)(((uint16_t)(x)) << WDOG_STCTRLH_IRQRSTEN_SHIFT)) & WDOG_STCTRLH_IRQRSTEN_MASK)
 
#define WDOG_STCTRLH_WINEN_MASK   (0x8U)
 
#define WDOG_STCTRLH_WINEN_SHIFT   (3U)
 
#define WDOG_STCTRLH_WINEN(x)   (((uint16_t)(((uint16_t)(x)) << WDOG_STCTRLH_WINEN_SHIFT)) & WDOG_STCTRLH_WINEN_MASK)
 
#define WDOG_STCTRLH_ALLOWUPDATE_MASK   (0x10U)
 
#define WDOG_STCTRLH_ALLOWUPDATE_SHIFT   (4U)
 
#define WDOG_STCTRLH_ALLOWUPDATE(x)   (((uint16_t)(((uint16_t)(x)) << WDOG_STCTRLH_ALLOWUPDATE_SHIFT)) & WDOG_STCTRLH_ALLOWUPDATE_MASK)
 
#define WDOG_STCTRLH_DBGEN_MASK   (0x20U)
 
#define WDOG_STCTRLH_DBGEN_SHIFT   (5U)
 
#define WDOG_STCTRLH_DBGEN(x)   (((uint16_t)(((uint16_t)(x)) << WDOG_STCTRLH_DBGEN_SHIFT)) & WDOG_STCTRLH_DBGEN_MASK)
 
#define WDOG_STCTRLH_STOPEN_MASK   (0x40U)
 
#define WDOG_STCTRLH_STOPEN_SHIFT   (6U)
 
#define WDOG_STCTRLH_STOPEN(x)   (((uint16_t)(((uint16_t)(x)) << WDOG_STCTRLH_STOPEN_SHIFT)) & WDOG_STCTRLH_STOPEN_MASK)
 
#define WDOG_STCTRLH_WAITEN_MASK   (0x80U)
 
#define WDOG_STCTRLH_WAITEN_SHIFT   (7U)
 
#define WDOG_STCTRLH_WAITEN(x)   (((uint16_t)(((uint16_t)(x)) << WDOG_STCTRLH_WAITEN_SHIFT)) & WDOG_STCTRLH_WAITEN_MASK)
 
#define WDOG_STCTRLH_TESTWDOG_MASK   (0x400U)
 
#define WDOG_STCTRLH_TESTWDOG_SHIFT   (10U)
 
#define WDOG_STCTRLH_TESTWDOG(x)   (((uint16_t)(((uint16_t)(x)) << WDOG_STCTRLH_TESTWDOG_SHIFT)) & WDOG_STCTRLH_TESTWDOG_MASK)
 
#define WDOG_STCTRLH_TESTSEL_MASK   (0x800U)
 
#define WDOG_STCTRLH_TESTSEL_SHIFT   (11U)
 
#define WDOG_STCTRLH_TESTSEL(x)   (((uint16_t)(((uint16_t)(x)) << WDOG_STCTRLH_TESTSEL_SHIFT)) & WDOG_STCTRLH_TESTSEL_MASK)
 
#define WDOG_STCTRLH_BYTESEL_MASK   (0x3000U)
 
#define WDOG_STCTRLH_BYTESEL_SHIFT   (12U)
 
#define WDOG_STCTRLH_BYTESEL(x)   (((uint16_t)(((uint16_t)(x)) << WDOG_STCTRLH_BYTESEL_SHIFT)) & WDOG_STCTRLH_BYTESEL_MASK)
 
#define WDOG_STCTRLH_DISTESTWDOG_MASK   (0x4000U)
 
#define WDOG_STCTRLH_DISTESTWDOG_SHIFT   (14U)
 
#define WDOG_STCTRLH_DISTESTWDOG(x)   (((uint16_t)(((uint16_t)(x)) << WDOG_STCTRLH_DISTESTWDOG_SHIFT)) & WDOG_STCTRLH_DISTESTWDOG_MASK)
 
STCTRLL - Watchdog Status and Control Register Low
#define WDOG_STCTRLL_INTFLG_MASK   (0x8000U)
 
#define WDOG_STCTRLL_INTFLG_SHIFT   (15U)
 
#define WDOG_STCTRLL_INTFLG(x)   (((uint16_t)(((uint16_t)(x)) << WDOG_STCTRLL_INTFLG_SHIFT)) & WDOG_STCTRLL_INTFLG_MASK)
 
TOVALH - Watchdog Time-out Value Register High
#define WDOG_TOVALH_TOVALHIGH_MASK   (0xFFFFU)
 
#define WDOG_TOVALH_TOVALHIGH_SHIFT   (0U)
 
#define WDOG_TOVALH_TOVALHIGH(x)   (((uint16_t)(((uint16_t)(x)) << WDOG_TOVALH_TOVALHIGH_SHIFT)) & WDOG_TOVALH_TOVALHIGH_MASK)
 
TOVALL - Watchdog Time-out Value Register Low
#define WDOG_TOVALL_TOVALLOW_MASK   (0xFFFFU)
 
#define WDOG_TOVALL_TOVALLOW_SHIFT   (0U)
 
#define WDOG_TOVALL_TOVALLOW(x)   (((uint16_t)(((uint16_t)(x)) << WDOG_TOVALL_TOVALLOW_SHIFT)) & WDOG_TOVALL_TOVALLOW_MASK)
 
WINH - Watchdog Window Register High
#define WDOG_WINH_WINHIGH_MASK   (0xFFFFU)
 
#define WDOG_WINH_WINHIGH_SHIFT   (0U)
 
#define WDOG_WINH_WINHIGH(x)   (((uint16_t)(((uint16_t)(x)) << WDOG_WINH_WINHIGH_SHIFT)) & WDOG_WINH_WINHIGH_MASK)
 
WINL - Watchdog Window Register Low
#define WDOG_WINL_WINLOW_MASK   (0xFFFFU)
 
#define WDOG_WINL_WINLOW_SHIFT   (0U)
 
#define WDOG_WINL_WINLOW(x)   (((uint16_t)(((uint16_t)(x)) << WDOG_WINL_WINLOW_SHIFT)) & WDOG_WINL_WINLOW_MASK)
 
REFRESH - Watchdog Refresh register
#define WDOG_REFRESH_WDOGREFRESH_MASK   (0xFFFFU)
 
#define WDOG_REFRESH_WDOGREFRESH_SHIFT   (0U)
 
#define WDOG_REFRESH_WDOGREFRESH(x)   (((uint16_t)(((uint16_t)(x)) << WDOG_REFRESH_WDOGREFRESH_SHIFT)) & WDOG_REFRESH_WDOGREFRESH_MASK)
 
UNLOCK - Watchdog Unlock register
#define WDOG_UNLOCK_WDOGUNLOCK_MASK   (0xFFFFU)
 
#define WDOG_UNLOCK_WDOGUNLOCK_SHIFT   (0U)
 
#define WDOG_UNLOCK_WDOGUNLOCK(x)   (((uint16_t)(((uint16_t)(x)) << WDOG_UNLOCK_WDOGUNLOCK_SHIFT)) & WDOG_UNLOCK_WDOGUNLOCK_MASK)
 
TMROUTH - Watchdog Timer Output Register High
#define WDOG_TMROUTH_TIMEROUTHIGH_MASK   (0xFFFFU)
 
#define WDOG_TMROUTH_TIMEROUTHIGH_SHIFT   (0U)
 
#define WDOG_TMROUTH_TIMEROUTHIGH(x)   (((uint16_t)(((uint16_t)(x)) << WDOG_TMROUTH_TIMEROUTHIGH_SHIFT)) & WDOG_TMROUTH_TIMEROUTHIGH_MASK)
 
TMROUTL - Watchdog Timer Output Register Low
#define WDOG_TMROUTL_TIMEROUTLOW_MASK   (0xFFFFU)
 
#define WDOG_TMROUTL_TIMEROUTLOW_SHIFT   (0U)
 
#define WDOG_TMROUTL_TIMEROUTLOW(x)   (((uint16_t)(((uint16_t)(x)) << WDOG_TMROUTL_TIMEROUTLOW_SHIFT)) & WDOG_TMROUTL_TIMEROUTLOW_MASK)
 
RSTCNT - Watchdog Reset Count register
#define WDOG_RSTCNT_RSTCNT_MASK   (0xFFFFU)
 
#define WDOG_RSTCNT_RSTCNT_SHIFT   (0U)
 
#define WDOG_RSTCNT_RSTCNT(x)   (((uint16_t)(((uint16_t)(x)) << WDOG_RSTCNT_RSTCNT_SHIFT)) & WDOG_RSTCNT_RSTCNT_MASK)
 
PRESC - Watchdog Prescaler register
#define WDOG_PRESC_PRESCVAL_MASK   (0x700U)
 
#define WDOG_PRESC_PRESCVAL_SHIFT   (8U)
 
#define WDOG_PRESC_PRESCVAL(x)   (((uint16_t)(((uint16_t)(x)) << WDOG_PRESC_PRESCVAL_SHIFT)) & WDOG_PRESC_PRESCVAL_MASK)
 

Typedefs

typedef enum IRQn IRQn_Type
 
typedef enum _dma_request_source dma_request_source_t
 Structure for the DMA hardware request. More...
 

Enumerations

enum  IRQn {
  NotAvail_IRQn = -128, NonMaskableInt_IRQn = -14, HardFault_IRQn = -13, MemoryManagement_IRQn = -12,
  BusFault_IRQn = -11, UsageFault_IRQn = -10, SVCall_IRQn = -5, DebugMonitor_IRQn = -4,
  PendSV_IRQn = -2, SysTick_IRQn = -1, DMA0_IRQn = 0, DMA1_IRQn = 1,
  DMA2_IRQn = 2, DMA3_IRQn = 3, DMA4_IRQn = 4, DMA5_IRQn = 5,
  DMA6_IRQn = 6, DMA7_IRQn = 7, DMA8_IRQn = 8, DMA9_IRQn = 9,
  DMA10_IRQn = 10, DMA11_IRQn = 11, DMA12_IRQn = 12, DMA13_IRQn = 13,
  DMA14_IRQn = 14, DMA15_IRQn = 15, DMA_Error_IRQn = 16, MCM_IRQn = 17,
  FTFE_IRQn = 18, Read_Collision_IRQn = 19, LVD_LVW_IRQn = 20, LLWU_IRQn = 21,
  WDOG_EWM_IRQn = 22, RNG_IRQn = 23, I2C0_IRQn = 24, I2C1_IRQn = 25,
  SPI0_IRQn = 26, SPI1_IRQn = 27, I2S0_Tx_IRQn = 28, I2S0_Rx_IRQn = 29,
  UART0_LON_IRQn = 30, UART0_RX_TX_IRQn = 31, UART0_ERR_IRQn = 32, UART1_RX_TX_IRQn = 33,
  UART1_ERR_IRQn = 34, UART2_RX_TX_IRQn = 35, UART2_ERR_IRQn = 36, UART3_RX_TX_IRQn = 37,
  UART3_ERR_IRQn = 38, ADC0_IRQn = 39, CMP0_IRQn = 40, CMP1_IRQn = 41,
  FTM0_IRQn = 42, FTM1_IRQn = 43, FTM2_IRQn = 44, CMT_IRQn = 45,
  RTC_IRQn = 46, RTC_Seconds_IRQn = 47, PIT0_IRQn = 48, PIT1_IRQn = 49,
  PIT2_IRQn = 50, PIT3_IRQn = 51, PDB0_IRQn = 52, USB0_IRQn = 53,
  USBDCD_IRQn = 54, Reserved71_IRQn = 55, DAC0_IRQn = 56, MCG_IRQn = 57,
  LPTMR0_IRQn = 58, PORTA_IRQn = 59, PORTB_IRQn = 60, PORTC_IRQn = 61,
  PORTD_IRQn = 62, PORTE_IRQn = 63, SWI_IRQn = 64, SPI2_IRQn = 65,
  UART4_RX_TX_IRQn = 66, UART4_ERR_IRQn = 67, UART5_RX_TX_IRQn = 68, UART5_ERR_IRQn = 69,
  CMP2_IRQn = 70, FTM3_IRQn = 71, DAC1_IRQn = 72, ADC1_IRQn = 73,
  I2C2_IRQn = 74, CAN0_ORed_Message_buffer_IRQn = 75, CAN0_Bus_Off_IRQn = 76, CAN0_Error_IRQn = 77,
  CAN0_Tx_Warning_IRQn = 78, CAN0_Rx_Warning_IRQn = 79, CAN0_Wake_Up_IRQn = 80, SDHC_IRQn = 81,
  ENET_1588_Timer_IRQn = 82, ENET_Transmit_IRQn = 83, ENET_Receive_IRQn = 84, ENET_Error_IRQn = 85
}
 
enum  _dma_request_source {
  kDmaRequestMux0Disable = 0|0x100U, kDmaRequestMux0Reserved1 = 1|0x100U, kDmaRequestMux0UART0Rx = 2|0x100U, kDmaRequestMux0UART0Tx = 3|0x100U,
  kDmaRequestMux0UART1Rx = 4|0x100U, kDmaRequestMux0UART1Tx = 5|0x100U, kDmaRequestMux0UART2Rx = 6|0x100U, kDmaRequestMux0UART2Tx = 7|0x100U,
  kDmaRequestMux0UART3Rx = 8|0x100U, kDmaRequestMux0UART3Tx = 9|0x100U, kDmaRequestMux0UART4 = 10|0x100U, kDmaRequestMux0UART5 = 11|0x100U,
  kDmaRequestMux0I2S0Rx = 12|0x100U, kDmaRequestMux0I2S0Tx = 13|0x100U, kDmaRequestMux0SPI0Rx = 14|0x100U, kDmaRequestMux0SPI0Tx = 15|0x100U,
  kDmaRequestMux0SPI1 = 16|0x100U, kDmaRequestMux0SPI2 = 17|0x100U, kDmaRequestMux0I2C0 = 18|0x100U, kDmaRequestMux0I2C1I2C2 = 19|0x100U,
  kDmaRequestMux0I2C1 = 19|0x100U, kDmaRequestMux0I2C2 = 19|0x100U, kDmaRequestMux0FTM0Channel0 = 20|0x100U, kDmaRequestMux0FTM0Channel1 = 21|0x100U,
  kDmaRequestMux0FTM0Channel2 = 22|0x100U, kDmaRequestMux0FTM0Channel3 = 23|0x100U, kDmaRequestMux0FTM0Channel4 = 24|0x100U, kDmaRequestMux0FTM0Channel5 = 25|0x100U,
  kDmaRequestMux0FTM0Channel6 = 26|0x100U, kDmaRequestMux0FTM0Channel7 = 27|0x100U, kDmaRequestMux0FTM1Channel0 = 28|0x100U, kDmaRequestMux0FTM1Channel1 = 29|0x100U,
  kDmaRequestMux0FTM2Channel0 = 30|0x100U, kDmaRequestMux0FTM2Channel1 = 31|0x100U, kDmaRequestMux0FTM3Channel0 = 32|0x100U, kDmaRequestMux0FTM3Channel1 = 33|0x100U,
  kDmaRequestMux0FTM3Channel2 = 34|0x100U, kDmaRequestMux0FTM3Channel3 = 35|0x100U, kDmaRequestMux0FTM3Channel4 = 36|0x100U, kDmaRequestMux0FTM3Channel5 = 37|0x100U,
  kDmaRequestMux0FTM3Channel6 = 38|0x100U, kDmaRequestMux0FTM3Channel7 = 39|0x100U, kDmaRequestMux0ADC0 = 40|0x100U, kDmaRequestMux0ADC1 = 41|0x100U,
  kDmaRequestMux0CMP0 = 42|0x100U, kDmaRequestMux0CMP1 = 43|0x100U, kDmaRequestMux0CMP2 = 44|0x100U, kDmaRequestMux0DAC0 = 45|0x100U,
  kDmaRequestMux0DAC1 = 46|0x100U, kDmaRequestMux0CMT = 47|0x100U, kDmaRequestMux0PDB = 48|0x100U, kDmaRequestMux0PortA = 49|0x100U,
  kDmaRequestMux0PortB = 50|0x100U, kDmaRequestMux0PortC = 51|0x100U, kDmaRequestMux0PortD = 52|0x100U, kDmaRequestMux0PortE = 53|0x100U,
  kDmaRequestMux0IEEE1588Timer0 = 54|0x100U, kDmaRequestMux0IEEE1588Timer1 = 55|0x100U, kDmaRequestMux0IEEE1588Timer2 = 56|0x100U, kDmaRequestMux0IEEE1588Timer3 = 57|0x100U,
  kDmaRequestMux0AlwaysOn58 = 58|0x100U, kDmaRequestMux0AlwaysOn59 = 59|0x100U, kDmaRequestMux0AlwaysOn60 = 60|0x100U, kDmaRequestMux0AlwaysOn61 = 61|0x100U,
  kDmaRequestMux0AlwaysOn62 = 62|0x100U, kDmaRequestMux0AlwaysOn63 = 63|0x100U
}
 Structure for the DMA hardware request. More...
 

Detailed Description

CMSIS Peripheral Access Layer for MK64F12.

Version
2.9
Date
2016-03-21 CMSIS Peripheral Access Layer for MK64F12

Macro Definition Documentation

◆ _MK64F12_H_

#define _MK64F12_H_

Symbol preventing repeated inclusion

◆ BITBAND_REG

#define BITBAND_REG (   Reg,
  Bit 
)    (BITBAND_REG32((Reg),(Bit)))

◆ BITBAND_REG16

#define BITBAND_REG16 (   Reg,
  Bit 
)    (*((uint16_t volatile*)(BITBAND_REGADDR((Reg),(Bit)))))

Macro to access a single bit of a peripheral register (bit band region 0x40000000 to 0x400FFFFF) using the bit-band alias region access. Can be used for peripherals with 16bit access allowed.

Parameters
RegRegister to access.
BitBit number to access.
Returns
Value of the targeted bit in the bit band region.

◆ BITBAND_REG32

#define BITBAND_REG32 (   Reg,
  Bit 
)    (*((uint32_t volatile*)(BITBAND_REGADDR((Reg),(Bit)))))

Macro to access a single bit of a peripheral register (bit band region 0x40000000 to 0x400FFFFF) using the bit-band alias region access. Can be used for peripherals with 32bit access allowed.

Parameters
RegRegister to access.
BitBit number to access.
Returns
Value of the targeted bit in the bit band region.

◆ BITBAND_REG8

#define BITBAND_REG8 (   Reg,
  Bit 
)    (*((uint8_t volatile*)(BITBAND_REGADDR((Reg),(Bit)))))

Macro to access a single bit of a peripheral register (bit band region 0x40000000 to 0x400FFFFF) using the bit-band alias region access. Can be used for peripherals with 8bit access allowed.

Parameters
RegRegister to access.
BitBit number to access.
Returns
Value of the targeted bit in the bit band region.

◆ BITBAND_REGADDR

#define BITBAND_REGADDR (   Reg,
  Bit 
)    (0x42000000u + (32u*((uint32_t)&(Reg) - (uint32_t)0x40000000u)) + (4u*((uint32_t)(Bit))))

Macro to calculate address of an aliased word in the peripheral bitband area for a peripheral register and bit (bit band region 0x40000000 to 0x400FFFFF).

Parameters
RegRegister to access.
BitBit number to access.
Returns
Address of the aliased word in the peripheral bitband area.

◆ MCU_MEM_MAP_VERSION

#define MCU_MEM_MAP_VERSION   0x0200U

Memory map major version (memory maps with equal major version number are compatible)

◆ MCU_MEM_MAP_VERSION_MINOR

#define MCU_MEM_MAP_VERSION_MINOR   0x0009U

Memory map minor version